@kubb/core 5.0.0-beta.40 → 5.0.0-beta.42

package/dist/{memoryStorage-Dkxnid2K.cjs → memoryStorage-Dldu8sRT.cjs}

@@ -26,6 +26,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#endregion
 let node_events = require("node:events");
 let node_util = require("node:util");
+let node_crypto = require("node:crypto");
+let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
 let _kubb_ast = require("@kubb/ast");
@@ -661,7 +663,7 @@ var URLPath = class {
 };
 //#endregion
 //#region package.json
-var version = "5.0.0-beta.40";
+var version = "5.0.0-beta.42";
 //#endregion
 //#region src/constants.ts
 /**
@@ -1230,6 +1232,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 (0, node_crypto.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: (0, node_path.relative)(root, path),
+					content: await (0, node_fs_promises.readFile)(path, "utf8")
+				})))
+			};
+		} catch {
+			return null;
+		}
+	}
+};
+//#endregion
 //#region src/definePlugin.ts
 /**
 * Wraps a plugin factory and returns a function that accepts user options and
@@ -2124,9 +2209,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) {
@@ -2351,8 +2437,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) => ({
@@ -2368,6 +2456,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 = (0, node_path.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({
@@ -2426,7 +2527,13 @@ var KubbDriver = class KubbDriver {
 				await hooks.emit("kubb:build:end", {
 					files: this.fileManager.files,
 					config,
-					outputDir: (0, node_path.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) {
@@ -2437,6 +2544,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 = (0, node_path.join)(outputRoot, relativePath);
+			this.fileManager.upsert((0, _kubb_ast.createFile)({
+				path: absolutePath,
+				baseName: (0, node_path.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[(0, node_path.relative)(outputRoot, absolutePath)] = source;
+		await cache.persist({
+			key: cacheKey,
+			snapshot: { files }
+		});
+	}
 	#filesPayload() {
 		const driver = this;
 		return {
@@ -2463,6 +2604,11 @@ var KubbDriver = class KubbDriver {
 	* A failing plugin contributes an error diagnostic so the rest of the build continues.
 	* Every plugin also contributes a `timing` diagnostic.
 	*
+	* Plugins run sequentially so `kubb:plugin:end` fires as each plugin completes, instead
+	* of all at once after every plugin has marched through the parallel batches together.
+	* That ordering is what drives the CLI's `Plugins N/M` counter; without it the bar would
+	* sit at the initial value until the very end of the run.
+	*
 	* When `entries` is empty or `this.inputNode` is `null`, every entry still gets a
 	* `kubb:plugin:end` so middleware listeners (the barrel writer and friends) complete.
 	*/
@@ -2507,15 +2653,16 @@ 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 = 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);
 		});
 		if (pruningStates.length > 0) {
-			const allSchemas = [];
-			for await (const schema of schemas) allSchemas.push(schema);
 			const includedOpsByState = new Map(pruningStates.map((state) => [state, []]));
-			for await (const operation of operations) for (const state of pruningStates) {
+			for (const operation of operationsBuffer) for (const state of pruningStates) {
 				const { exclude, include, override } = state.plugin.options;
 				if (state.generatorContext.resolver.resolveOptions(operation, {
 					options: state.plugin.options,
@@ -2525,7 +2672,7 @@ var KubbDriver = class KubbDriver {
 				}) !== null) includedOpsByState.get(state)?.push(operation);
 			}
 			for (const state of pruningStates) {
-				state.allowedSchemaNames = (0, _kubb_ast.collectUsedSchemaNames)(includedOpsByState.get(state) ?? [], allSchemas);
+				state.allowedSchemaNames = (0, _kubb_ast.collectUsedSchemaNames)(includedOpsByState.get(state) ?? [], schemasBuffer);
 				includedOpsByState.delete(state);
 			}
 		}
@@ -2587,20 +2734,20 @@ var KubbDriver = class KubbDriver {
 			checkAllowedNames: false,
 			emit: emitsOperationHook ? (node, ctx) => this.hooks.emit("kubb:generate:operation", node, ctx) : null
 		};
-		const needsCollectedOperations = this.hooks.listenerCount("kubb:generate:operations") > 0 || states.some((state) => state.generators.some((gen) => !!gen.operations));
-		const collectedOperations = needsCollectedOperations ? [] : void 0;
-		await forBatches(schemas, (nodes) => Promise.all(nodes.flatMap((node) => states.map((state) => dispatchNode(state, node, schemaDispatch)))), {
-			concurrency: 8,
-			flush: flushPending
-		});
-		await forBatches(operations, (nodes) => {
-			if (needsCollectedOperations) collectedOperations?.push(...nodes);
-			return Promise.all(nodes.flatMap((node) => states.map((state) => dispatchNode(state, node, operationDispatch))));
-		}, {
-			concurrency: 8,
-			flush: flushPending
-		});
 		for (const state of states) {
+			const needsCollectedOperations = emitsOperationsHook || state.generators.some((gen) => !!gen.operations);
+			const collectedOperations = needsCollectedOperations ? [] : void 0;
+			await forBatches(schemasBuffer, (nodes) => Promise.all(nodes.map((node) => dispatchNode(state, node, schemaDispatch))), {
+				concurrency: 8,
+				flush: flushPending
+			});
+			await forBatches(operationsBuffer, (nodes) => {
+				if (needsCollectedOperations) collectedOperations?.push(...nodes);
+				return Promise.all(nodes.map((node) => dispatchNode(state, node, operationDispatch)));
+			}, {
+				concurrency: 8,
+				flush: flushPending
+			});
 			if (!state.failed && needsCollectedOperations) try {
 				const { plugin, generatorContext, generators } = state;
 				const ctx = {
@@ -2982,4 +3129,4 @@ Object.defineProperty(exports, "memoryStorage", {
 	}
 });
 
-//# sourceMappingURL=memoryStorage-Dkxnid2K.cjs.map
+//# sourceMappingURL=memoryStorage-Dldu8sRT.cjs.map