@kubb/core 5.0.0-beta.75 → 5.0.0-beta.8

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_PluginDriver = require("./PluginDriver-BXibeQk-.cjs");
+const require_PluginDriver = require("./PluginDriver-Cu1Kj9S-.cjs");
 let node_events = require("node:events");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
@@ -524,6 +524,9 @@ function createAdapter(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
+//#region package.json
+var version = "5.0.0-beta.8";
+//#endregion
 //#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
 var Node = class {
 	value;
@@ -735,12 +738,6 @@ function createStorage(build) {
 //#endregion
 //#region src/storages/fsStorage.ts
 /**
-* Detects the filesystem error used to indicate that a path does not exist.
-*/
-function isMissingPathError(error) {
-	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-/**
 * Built-in filesystem storage driver.
 *
 * This is the default storage when no `storage` option is configured in the root config.
@@ -771,17 +768,15 @@ const fsStorage = createStorage(() => ({
 		try {
 			await (0, node_fs_promises.access)((0, node_path.resolve)(key));
 			return true;
-		} catch (error) {
-			if (isMissingPathError(error)) return false;
-			throw new Error(`Failed to access storage item "${key}"`, { cause: error });
+		} catch (_error) {
+			return false;
 		}
 	},
 	async getItem(key) {
 		try {
 			return await (0, node_fs_promises.readFile)((0, node_path.resolve)(key), "utf8");
-		} catch (error) {
-			if (isMissingPathError(error)) return null;
-			throw new Error(`Failed to read storage item "${key}"`, { cause: error });
+		} catch (_error) {
+			return null;
 		}
 	},
 	async setItem(key, value) {
@@ -797,9 +792,8 @@ const fsStorage = createStorage(() => ({
 			let entries;
 			try {
 				entries = await (0, node_fs_promises.readdir)(dir, { withFileTypes: true });
-			} catch (error) {
-				if (isMissingPathError(error)) return;
-				throw new Error(`Failed to list storage keys under "${resolvedBase}"`, { cause: error });
+			} catch (_error) {
+				return;
 			}
 			for (const entry of entries) {
 				const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
@@ -816,37 +810,31 @@ const fsStorage = createStorage(() => ({
 	}
 }));
 //#endregion
-//#region package.json
-var version = "5.0.0-beta.75";
-//#endregion
-//#region src/utils/diagnostics.ts
-/**
-* Returns a snapshot of the current runtime environment.
-*
-* Useful for attaching context to debug logs and error reports so that
-* issues can be reproduced without manual information gathering.
-*/
-function getDiagnosticInfo() {
-	return {
-		nodeVersion: node_process.version,
-		KubbVersion: version,
-		platform: process.platform,
-		arch: process.arch,
-		cwd: process.cwd()
-	};
-}
-//#endregion
-//#region src/utils/isInputPath.ts
-function isInputPath(config) {
-	return typeof config?.input === "object" && config.input !== null && "path" in config.input;
-}
-//#endregion
 //#region src/createKubb.ts
 async function setup(userConfig, options = {}) {
 	const hooks = options.hooks ?? new AsyncEventEmitter();
+	const config = {
+		...userConfig,
+		root: userConfig.root || process.cwd(),
+		parsers: userConfig.parsers ?? [],
+		adapter: userConfig.adapter,
+		output: {
+			format: false,
+			lint: false,
+			extension: require_PluginDriver.DEFAULT_EXTENSION,
+			defaultBanner: require_PluginDriver.DEFAULT_BANNER,
+			...userConfig.output
+		},
+		storage: userConfig.storage ?? fsStorage(),
+		devtools: userConfig.devtools ? {
+			studioUrl: require_PluginDriver.DEFAULT_STUDIO_URL,
+			...typeof userConfig.devtools === "boolean" ? {} : userConfig.devtools
+		} : void 0,
+		plugins: userConfig.plugins ?? []
+	};
+	const driver = new require_PluginDriver.PluginDriver(config, { hooks });
 	const sources = /* @__PURE__ */ new Map();
 	const diagnosticInfo = getDiagnosticInfo();
-	if (Array.isArray(userConfig.input)) await hooks.emit("kubb:warn", { message: "This feature is still under development — use with caution" });
 	await hooks.emit("kubb:debug", {
 		date: /* @__PURE__ */ new Date(),
 		logs: [
@@ -856,7 +844,7 @@ async function setup(userConfig, options = {}) {
 			`  • Output: ${userConfig.output?.path || "not specified"}`,
 			`  • Plugins: ${userConfig.plugins?.length || 0}`,
 			"Output Settings:",
-			`  • Storage: ${userConfig.storage ? `custom(${userConfig.storage.name})` : userConfig.output?.write === false ? "disabled" : "filesystem (default)"}`,
+			`  • Storage: ${config.storage.name}`,
 			`  • Formatter: ${userConfig.output?.format || "none"}`,
 			`  • Linter: ${userConfig.output?.lint || "none"}`,
 			"Environment:",
@@ -877,73 +865,56 @@ async function setup(userConfig, options = {}) {
 			throw new Error(`Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${userConfig.input.path}`, { cause: error });
 		}
 	}
-	if (!userConfig.adapter) throw new Error("Adapter should be defined");
-	const config = {
-		...userConfig,
-		root: userConfig.root || process.cwd(),
-		parsers: userConfig.parsers ?? [],
-		adapter: userConfig.adapter,
-		output: {
-			format: false,
-			lint: false,
-			write: true,
-			extension: require_PluginDriver.DEFAULT_EXTENSION,
-			defaultBanner: require_PluginDriver.DEFAULT_BANNER,
-			...userConfig.output
-		},
-		devtools: userConfig.devtools ? {
-			studioUrl: require_PluginDriver.DEFAULT_STUDIO_URL,
-			...typeof userConfig.devtools === "boolean" ? {} : userConfig.devtools
-		} : void 0,
-		plugins: userConfig.plugins
-	};
-	const storage = config.output.write === false ? null : config.storage ?? fsStorage();
 	if (config.output.clean) {
 		await hooks.emit("kubb:debug", {
 			date: /* @__PURE__ */ new Date(),
 			logs: ["Cleaning output directories", `  • Output: ${config.output.path}`]
 		});
-		await storage?.clear((0, node_path.resolve)(config.root, config.output.path));
+		await config.storage.clear((0, node_path.resolve)(config.root, config.output.path));
 	}
-	const driver = new require_PluginDriver.PluginDriver(config, { hooks });
 	function registerMiddlewareHook(event, middlewareHooks) {
 		const handler = middlewareHooks[event];
 		if (handler) hooks.on(event, handler);
 	}
 	for (const middleware of config.middleware ?? []) for (const event of Object.keys(middleware.hooks)) registerMiddlewareHook(event, middleware.hooks);
-	const adapter = config.adapter;
-	if (!adapter) throw new Error("No adapter configured. Please provide an adapter in your kubb.config.ts.");
-	const source = inputToAdapterSource(config);
-	await hooks.emit("kubb:debug", {
-		date: /* @__PURE__ */ new Date(),
-		logs: [`Running adapter: ${adapter.name}`]
-	});
-	driver.adapter = adapter;
-	driver.inputNode = await adapter.parse(source);
-	await hooks.emit("kubb:debug", {
-		date: /* @__PURE__ */ new Date(),
-		logs: [
-			`✓ Adapter '${adapter.name}' resolved InputNode`,
-			`  • Schemas: ${driver.inputNode.schemas.length}`,
-			`  • Operations: ${driver.inputNode.operations.length}`
-		]
-	});
+	if (config.adapter) {
+		const source = inputToAdapterSource(config);
+		await hooks.emit("kubb:debug", {
+			date: /* @__PURE__ */ new Date(),
+			logs: [`Running adapter: ${config.adapter.name}`]
+		});
+		driver.adapter = config.adapter;
+		driver.inputNode = await config.adapter.parse(source);
+		await hooks.emit("kubb:debug", {
+			date: /* @__PURE__ */ new Date(),
+			logs: [
+				`✓ Adapter '${config.adapter.name}' resolved InputNode`,
+				`  • Schemas: ${driver.inputNode.schemas.length}`,
+				`  • Operations: ${driver.inputNode.operations.length}`
+			]
+		});
+	}
 	return {
 		config,
 		hooks,
 		driver,
-		sources,
-		storage
+		sources
 	};
 }
 /**
 * Walks the AST and dispatches nodes to a plugin's direct AST hooks
 * (`schema`, `operation`, `operations`).
+*
+* When `include` contains only operation-scoped filters (`tag`, `operationId`, `path`,
+* `method`, `contentType`) and no `schemaName` filter, the function pre-computes the set
+* of top-level schema names transitively reachable from the included operations and skips
+* schemas that fall outside that set. This ensures that component schemas referenced
+* exclusively by excluded operations are not generated.
 */
 async function runPluginAstHooks(plugin, context) {
 	const { adapter, inputNode, resolver, driver } = context;
 	const { exclude, include, override } = plugin.options;
-	if (!adapter || !inputNode) throw new Error(`[${plugin.name}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`);
+	if (!adapter || !inputNode) throw new Error(`[${plugin.name}] No adapter found. Add an OAS adapter (e.g. adapterOas()) before this plugin in your Kubb config.`);
 	function resolveRenderer(gen) {
 		return gen.renderer === null ? void 0 : gen.renderer ?? plugin.renderer ?? context.config.renderer;
 	}
@@ -953,10 +924,27 @@ async function runPluginAstHooks(plugin, context) {
 		...context,
 		resolver: driver.getResolver(plugin.name)
 	};
+	const operationFilterTypes = new Set([
+		"tag",
+		"operationId",
+		"path",
+		"method",
+		"contentType"
+	]);
+	const hasOperationBasedIncludes = include?.some(({ type }) => operationFilterTypes.has(type)) ?? false;
+	const hasSchemaNameIncludes = include?.some(({ type }) => type === "schemaName") ?? false;
+	let allowedSchemaNames;
+	if (hasOperationBasedIncludes && !hasSchemaNameIncludes) allowedSchemaNames = (0, _kubb_ast.collectUsedSchemaNames)(inputNode.operations.filter((op) => resolver.resolveOptions(op, {
+		options: plugin.options,
+		exclude,
+		include,
+		override
+	}) !== null), inputNode.schemas);
 	await (0, _kubb_ast.walk)(inputNode, {
 		depth: "shallow",
 		async schema(node) {
 			const transformedNode = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
+			if (allowedSchemaNames !== void 0 && transformedNode.name && !allowedSchemaNames.has(transformedNode.name)) return;
 			const options = resolver.resolveOptions(transformedNode, {
 				options: plugin.options,
 				exclude,
@@ -1009,7 +997,7 @@ async function runPluginAstHooks(plugin, context) {
 	}
 }
 async function safeBuild(setupResult) {
-	const { driver, hooks, sources, storage } = setupResult;
+	const { driver, hooks, sources } = setupResult;
 	const failedPlugins = /* @__PURE__ */ new Set();
 	const pluginTimings = /* @__PURE__ */ new Map();
 	const config = driver.config;
@@ -1100,6 +1088,7 @@ async function safeBuild(setupResult) {
 		});
 		await fileProcessor.run(files, {
 			parsers: parsersMap,
+			mode: "parallel",
 			extension: config.output.extension,
 			onStart: async (processingFiles) => {
 				await hooks.emit("kubb:files:processing:start", { files: processingFiles });
@@ -1114,7 +1103,7 @@ async function safeBuild(setupResult) {
 					config
 				});
 				if (source) {
-					await storage?.setItem(file.path, source);
+					await config.storage.setItem(file.path, source);
 					sources.set(file.path, source);
 				}
 			},
@@ -1167,22 +1156,38 @@ async function build(setupResult) {
 		sources
 	};
 }
-function inputToAdapterSource(config) {
-	if (Array.isArray(config.input)) return {
-		type: "paths",
-		paths: config.input.map((i) => new URLPath(i.path).isURL ? i.path : (0, node_path.resolve)(config.root, i.path))
+/**
+* Returns a snapshot of the current runtime environment.
+*
+* Useful for attaching context to debug logs and error reports so that
+* issues can be reproduced without manual information gathering.
+*/
+function getDiagnosticInfo() {
+	return {
+		nodeVersion: node_process.version,
+		KubbVersion: version,
+		platform: process.platform,
+		arch: process.arch,
+		cwd: process.cwd()
 	};
-	if ("data" in config.input) return {
+}
+function isInputPath(config) {
+	return typeof config?.input === "object" && config.input !== null && "path" in config.input;
+}
+function inputToAdapterSource(config) {
+	const input = config.input;
+	if (!input) throw new Error("[kubb] input is required when using an adapter. Provide input.path or input.data in your config.");
+	if ("data" in input) return {
 		type: "data",
-		data: config.input.data
+		data: input.data
 	};
-	if (new URLPath(config.input.path).isURL) return {
+	if (new URLPath(input.path).isURL) return {
 		type: "path",
-		path: config.input.path
+		path: input.path
 	};
 	return {
 		type: "path",
-		path: (0, node_path.resolve)(config.root, config.input.path)
+		path: (0, node_path.resolve)(config.root, input.path)
 	};
 }
 /**
@@ -1282,7 +1287,11 @@ function defineGenerator(generator) {
 /**
 * Wraps a logger definition into a typed {@link Logger}.
 *
-* @example
+* The optional second type parameter `TInstallReturn` allows loggers to return
+* a value from `install` — for example, a sink factory that the caller can
+* forward to hook execution.
+*
+* @example Basic logger
 * ```ts
 * export const myLogger = defineLogger({
 *   name: 'my-logger',
@@ -1292,6 +1301,17 @@ function defineGenerator(generator) {
 *   },
 * })
 * ```
+*
+* @example Logger that returns a hook sink factory
+* ```ts
+* export const myLogger = defineLogger<LoggerOptions, HookSinkFactory>({
+*   name: 'my-logger',
+*   install(context, options) {
+*     // … register event handlers …
+*     return (commandWithArgs) => ({ onStdout: console.log })
+*   },
+* })
+* ```
 */
 function defineLogger(logger) {
 	return logger;
@@ -1362,34 +1382,6 @@ function defineParser(parser) {
 	return parser;
 }
 //#endregion
-//#region src/definePlugin.ts
-/**
-* Wraps a factory function and returns a typed `Plugin` with lifecycle handlers grouped under `hooks`.
-*
-* Handlers live in a single `hooks` object (inspired by Astro integrations).
-* All lifecycle events from `KubbHooks` are available for subscription.
-*
-* @note For real plugins, use a `PluginFactoryOptions` type parameter to get type-safe context in `kubb:plugin:setup`.
-* Plugin names should follow the convention `plugin-<feature>` (e.g., `plugin-react-query`, `plugin-zod`).
-*
-* @example
-* ```ts
-* import { definePlugin } from '@kubb/core'
-*
-* export const pluginTs = definePlugin((options: { prefix?: string } = {}) => ({
-*   name: 'plugin-ts',
-*   hooks: {
-*     'kubb:plugin:setup'(ctx) {
-*       ctx.setResolver(resolverTs)
-*     },
-*   },
-* }))
-* ```
-*/
-function definePlugin(factory) {
-	return (options) => factory(options ?? {});
-}
-//#endregion
 //#region src/storages/memoryStorage.ts
 /**
 * In-memory storage driver. Useful for testing and dry-run scenarios where
@@ -1459,7 +1451,7 @@ exports.defineGenerator = defineGenerator;
 exports.defineLogger = defineLogger;
 exports.defineMiddleware = defineMiddleware;
 exports.defineParser = defineParser;
-exports.definePlugin = definePlugin;
+exports.definePlugin = require_PluginDriver.definePlugin;
 exports.defineResolver = require_PluginDriver.defineResolver;
 exports.fsStorage = fsStorage;
 exports.isInputPath = isInputPath;