orval 8.0.0-rc.1 → 8.0.0-rc.3

package/dist/{generate-6oT76j_W.js → config-CJTbXPiX.mjs}

@@ -1,12 +1,8 @@
-import { ErrorWithTag, FormDataArrayHandling, GetterPropType, NamingConvention, OutputClient, OutputHttpClient, OutputMode, PropertySortOrder, RefComponentSuffix, asyncReduce, createLogger, createSuccessMessage, dynamicImport, generateComponentDefinition, generateDependencyImports, generateParameterDefinition, generateSchemasDefinition, generateVerbsOptions, getFileInfo, getFullRoute, getMockFileExtensionByTypeName, getRoute, ibmOpenapiValidator, isBoolean, isFunction, isObject, isReference, isRootKey, isSchema, isString, isUndefined, isUrl, jsDoc, log, logError, mergeDeep, openApiConverter, pascal, removeFilesAndEmptyFolders, resolveRef, upath, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode } from "@orval/core";
-import fs from "node:fs";
 import path from "node:path";
-import process$1 from "node:process";
-import { createJiti } from "jiti";
-import SwaggerParser from "@apidevtools/swagger-parser";
-import chalk from "chalk";
-import fs$1 from "fs-extra";
-import yaml from "js-yaml";
+import { FormDataArrayHandling, GetterPropType, NamingConvention, OutputClient, OutputHttpClient, OutputMode, PropertySortOrder, RefComponentSuffix, asyncReduce, createLogger, createSuccessMessage, dynamicImport, generateComponentDefinition, generateDependencyImports, generateParameterDefinition, generateSchemasDefinition, generateVerbsOptions, getFileInfo, getFullRoute, getMockFileExtensionByTypeName, getRoute, isBoolean, isFunction, isObject, isReference, isString, isUndefined, isUrl, jsDoc, log, logError, pascal, removeFilesAndEmptyFolders, resolveRef, upath, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode } from "@orval/core";
+import { bundle } from "@scalar/json-magic/bundle";
+import { fetchUrls, parseJson, parseYaml, readFiles } from "@scalar/json-magic/bundle/plugins/node";
+import { upgrade, validate } from "@scalar/openapi-parser";
 import * as mock from "@orval/mock";
 import { DEFAULT_MOCK_OPTIONS, generateMockImports } from "@orval/mock";
 import angular from "@orval/angular";
@@ -17,14 +13,23 @@ import mcp from "@orval/mcp";
 import query from "@orval/query";
 import swr from "@orval/swr";
 import zod from "@orval/zod";
-import https from "node:https";
-import enquirer from "enquirer";
-import { findUp } from "find-up";
-import { parse } from "tsconfck";
+import chalk from "chalk";
 import { ExecaError, execa } from "execa";
+import fs from "fs-extra";
 import { unique } from "remeda";
 import { parseArgsStringToArgv } from "string-argv";
+import { findUp } from "find-up";
+import yaml from "js-yaml";
+import { parse } from "tsconfck";
+import fs$1 from "node:fs";
+import { createJiti } from "jiti";
+
+//#region package.json
+var name = "orval";
+var description = "A swagger client generator for typescript";
+var version = "8.0.0-rc.3";
 
+//#endregion
 //#region src/client.ts
 const DEFAULT_CLIENT = OutputClient.AXIOS;
 const getGeneratorClient = (outputClient, output) => {
@@ -54,9 +59,9 @@ const getGeneratorClient = (outputClient, output) => {
 	if (!generator) throw new Error(`Oups... 🍻. Client not found: ${outputClient}`);
 	return generator;
 };
-const generateClientImports = ({ client = DEFAULT_CLIENT, implementation, imports, specsName, hasSchemaDir, isAllowSyntheticDefaultImports, hasGlobalMutator, hasTagsMutator, hasParamsSerializerOptions, packageJson, output }) => {
+const generateClientImports = ({ client = DEFAULT_CLIENT, implementation, imports, projectName, hasSchemaDir, isAllowSyntheticDefaultImports, hasGlobalMutator, hasTagsMutator, hasParamsSerializerOptions, packageJson, output }) => {
 	const { dependencies } = getGeneratorClient(client, output);
-	return generateDependencyImports(implementation, dependencies ? [...dependencies(hasGlobalMutator, hasParamsSerializerOptions, packageJson, output.httpClient, hasTagsMutator, output.override), ...imports] : imports, specsName, hasSchemaDir, isAllowSyntheticDefaultImports);
+	return generateDependencyImports(implementation, dependencies ? [...dependencies(hasGlobalMutator, hasParamsSerializerOptions, packageJson, output.httpClient, hasTagsMutator, output.override), ...imports] : imports, projectName, hasSchemaDir, isAllowSyntheticDefaultImports);
 };
 const generateClientHeader = ({ outputClient = DEFAULT_CLIENT, isRequestOptions, isGlobalMutator, isMutator, provideIn, hasAwaitedType, titles, output, verbOptions, tag, clientImplementation }) => {
 	const { header } = getGeneratorClient(outputClient, output);
@@ -167,18 +172,13 @@ const generateExtraFiles = (outputClient = DEFAULT_CLIENT, verbsOptions, output,
 
 //#endregion
 //#region src/api.ts
-const getApiBuilder = async ({ input, output, context }) => {
-	const api = await asyncReduce(Object.entries(context.specs[context.specKey].paths ?? {}), async (acc, [pathRoute, verbs]) => {
+async function getApiBuilder({ input, output, context }) {
+	const api = await asyncReduce(Object.entries(context.spec.paths ?? {}), async (acc, [pathRoute, verbs]) => {
 		const route = getRoute(pathRoute);
 		let resolvedVerbs = verbs;
-		let resolvedContext = context;
 		if (isReference(verbs)) {
 			const { schema, imports } = resolveRef(verbs, context);
 			resolvedVerbs = schema;
-			resolvedContext = {
-				...context,
-				...imports.length > 0 ? { specKey: imports[0].specKey } : {}
-			};
 		}
 		let verbsOptions = await generateVerbsOptions({
 			verbs: resolvedVerbs,
@@ -186,7 +186,7 @@ const getApiBuilder = async ({ input, output, context }) => {
 			output,
 			route,
 			pathRoute,
-			context: resolvedContext
+			context
 		});
 		if (output.override.useDeprecatedOperations === false) verbsOptions = verbsOptions.filter((verb) => {
 			return !verb.deprecated;
@@ -198,13 +198,13 @@ const getApiBuilder = async ({ input, output, context }) => {
 			acc$1.push(...body.schemas, ...response.schemas);
 			return acc$1;
 		}, []);
-		const fullRoute = getFullRoute(route, verbs.servers ?? context.specs[context.specKey].servers, output.baseUrl);
+		const fullRoute = getFullRoute(route, verbs.servers ?? context.spec.servers, output.baseUrl);
 		if (!output.target) throw new Error("Output does not have a target");
 		const pathOperations = await generateOperations(output.client, verbsOptions, {
 			route: fullRoute,
 			pathRoute,
 			override: output.override,
-			context: resolvedContext,
+			context,
 			mock: output.mock,
 			output: output.target
 		}, output);
@@ -232,278 +232,167 @@ const getApiBuilder = async ({ input, output, context }) => {
 		importsMock: generateMockImports,
 		extraFiles
 	};
-};
+}
 
 //#endregion
 //#region src/import-open-api.ts
-const importOpenApi = async ({ data, input, output, target, workspace }) => {
-	const specs = await generateInputSpecs({
-		specs: data,
-		input,
-		workspace
-	});
+async function importOpenApi({ spec, input, output, target, workspace, projectName }) {
+	const transformedOpenApi = await applyTransformer(spec, input.override.transformer, workspace);
 	const schemas = getApiSchemas({
 		input,
 		output,
 		target,
 		workspace,
-		specs
+		spec: transformedOpenApi
 	});
 	const api = await getApiBuilder({
 		input,
 		output,
 		context: {
-			specKey: target,
+			projectName,
 			target,
 			workspace,
-			specs,
+			spec: transformedOpenApi,
 			output
 		}
 	});
 	return {
 		...api,
-		schemas: {
-			...schemas,
-			[target]: [...schemas[target] ?? [], ...api.schemas]
-		},
+		schemas: [...schemas, ...api.schemas],
 		target,
-		info: specs[target].info
+		info: transformedOpenApi.info
 	};
-};
-const generateInputSpecs = async ({ specs, input, workspace }) => {
-	const transformerFn = input.override?.transformer ? await dynamicImport(input.override.transformer, workspace) : void 0;
-	return asyncReduce(Object.entries(specs), async (acc, [specKey, value]) => {
-		const schema = await openApiConverter(value, input.converterOptions, specKey);
-		const transfomedSchema = transformerFn ? transformerFn(schema) : schema;
-		if (input.validation) await ibmOpenapiValidator(transfomedSchema, input.validation);
-		acc[specKey] = transfomedSchema;
-		return acc;
-	}, {});
-};
-const getApiSchemas = ({ input, output, target, workspace, specs }) => {
-	return Object.entries(specs).reduce((acc, [specKey, spec]) => {
-		const context = {
-			specKey,
-			target,
-			workspace,
-			specs,
-			output
-		};
-		const schemaDefinition = generateSchemasDefinition(spec.openapi ? spec.components?.schemas : getAllSchemas(spec, specKey), context, output.override.components.schemas.suffix, input.filters);
-		const responseDefinition = generateComponentDefinition(spec.components?.responses, context, output.override.components.responses.suffix);
-		const bodyDefinition = generateComponentDefinition(spec.components?.requestBodies, context, output.override.components.requestBodies.suffix);
-		const parameters = generateParameterDefinition(spec.components?.parameters, context, output.override.components.parameters.suffix);
-		const schemas = [
-			...schemaDefinition,
-			...responseDefinition,
-			...bodyDefinition,
-			...parameters
-		];
-		if (schemas.length === 0) return acc;
-		acc[specKey] = schemas;
-		return acc;
-	}, {});
-};
-const getAllSchemas = (spec, specKey) => {
-	const keysToOmit = new Set([
-		"openapi",
-		"info",
-		"servers",
-		"paths",
-		"components",
-		"security",
-		"tags",
-		"externalDocs"
-	]);
-	const cleanedSpec = Object.fromEntries(Object.entries(spec).filter(([key]) => !keysToOmit.has(key)));
-	if (specKey && isSchema(cleanedSpec)) {
-		const name$1 = upath.getSchemaFileName(specKey);
-		const additionalKeysToOmit = new Set([
-			"type",
-			"properties",
-			"allOf",
-			"oneOf",
-			"anyOf",
-			"items"
-		]);
-		return {
-			[name$1]: cleanedSpec,
-			...getAllSchemas(Object.fromEntries(Object.entries(cleanedSpec).filter(([key]) => !additionalKeysToOmit.has(key))))
-		};
-	}
-	return {
-		...Object.entries(cleanedSpec).reduce((acc, [key, value]) => {
-			if (!isObject(value)) return acc;
-			if (!isSchema(value) && !isReference(value)) return {
-				...acc,
-				...getAllSchemas(value)
-			};
-			acc[key] = value;
-			return acc;
-		}, {}),
-		...spec?.components?.schemas
+}
+async function applyTransformer(openApi, transformer, workspace) {
+	const transformerFn = transformer ? await dynamicImport(transformer, workspace) : void 0;
+	if (!transformerFn) return openApi;
+	const transformedOpenApi = transformerFn(openApi);
+	const { valid, errors } = await validate(transformedOpenApi);
+	if (!valid) throw new Error(`Validation failed`, { cause: errors });
+	return transformedOpenApi;
+}
+function getApiSchemas({ input, output, target, workspace, spec }) {
+	const context = {
+		target,
+		workspace,
+		spec,
+		output
 	};
-};
+	const schemaDefinition = generateSchemasDefinition(spec.components?.schemas, context, output.override.components.schemas.suffix, input.filters);
+	const responseDefinition = generateComponentDefinition(spec.components?.responses, context, output.override.components.responses.suffix);
+	const bodyDefinition = generateComponentDefinition(spec.components?.requestBodies, context, output.override.components.requestBodies.suffix);
+	const parameters = generateParameterDefinition(spec.components?.parameters, context, output.override.components.parameters.suffix);
+	return [
+		...schemaDefinition,
+		...responseDefinition,
+		...bodyDefinition,
+		...parameters
+	];
+}
 
 //#endregion
 //#region src/import-specs.ts
-const resolveSpecs = async (path$1, { validate,...options }, _isUrl, isOnlySchema) => {
-	try {
-		if (validate) try {
-			await SwaggerParser.validate(path$1, options);
-		} catch (error) {
-			if (error instanceof Error && error.name === "ParserError") throw error;
-			if (!isOnlySchema) log(`⚠️  ${chalk.yellow(error)}`);
-		}
-		const data = (await SwaggerParser.resolve(path$1, options)).values();
-		if (_isUrl) return data;
-		return Object.fromEntries(Object.entries(data).sort().map(([key, value]) => [isUrl(key) ? key : upath.resolve(key), value]));
-	} catch {
-		const file = await fs$1.readFile(path$1, "utf8");
-		return { [path$1]: yaml.load(file) };
-	}
-};
-const importSpecs = async (workspace, options) => {
+async function resolveSpec(input) {
+	const dereferencedData = dereferenceExternalRef(await bundle(input, {
+		plugins: [
+			readFiles(),
+			fetchUrls(),
+			parseJson(),
+			parseYaml()
+		],
+		treeShake: true
+	}));
+	const { valid, errors } = await validate(dereferencedData);
+	if (!valid) throw new Error("Validation failed", { cause: errors });
+	const { specification } = upgrade(dereferencedData);
+	return specification;
+}
+async function importSpecs(workspace, options, projectName) {
 	const { input, output } = options;
-	if (!isString(input.target)) return importOpenApi({
-		data: { [workspace]: input.target },
-		input,
-		output,
-		target: workspace,
-		workspace
-	});
-	const isPathUrl = isUrl(input.target);
 	return importOpenApi({
-		data: await resolveSpecs(input.target, input.parserOptions, isPathUrl, !output.target),
+		spec: await resolveSpec(input.target),
 		input,
 		output,
 		target: input.target,
-		workspace
-	});
-};
-
-//#endregion
-//#region package.json
-var name = "orval";
-var description = "A swagger client generator for typescript";
-var version = "8.0.0-rc.1";
-
-//#endregion
-//#region src/utils/request.ts
-const request = (urlOptions, data) => {
-	return new Promise((resolve, reject) => {
-		const req = https.request(urlOptions, (res) => {
-			let body = "";
-			res.on("data", (chunk) => body += chunk.toString());
-			res.on("error", reject);
-			res.on("end", () => {
-				const response = {
-					status: res.statusCode,
-					headers: res.headers,
-					body: JSON.parse(body)
-				};
-				if (res.statusCode && res.statusCode >= 200 && res.statusCode <= 299) resolve(response);
-				else reject(response);
-			});
-		});
-		req.on("error", reject);
-		if (data) req.write(data, "binary");
-		req.end();
+		workspace,
+		projectName
 	});
-};
-
-//#endregion
-//#region src/utils/github.ts
-const getGithubSpecReq = ({ accessToken, repo, owner, branch, path: path$1 }) => {
-	const payload = JSON.stringify({ query: `query {
-      repository(name: "${repo}", owner: "${owner}") {
-        object(expression: "${branch}:${path$1}") {
-          ... on Blob {
-            text
-          }
-        }
-      }
-    }` });
-	return [{
-		method: "POST",
-		hostname: "api.github.com",
-		path: "/graphql",
-		headers: {
-			"content-type": "application/json",
-			"user-agent": "orval-importer",
-			authorization: `bearer ${accessToken}`,
-			"Content-Length": payload.length
+}
+/**
+* The plugins from `@scalar/json-magic` does not dereference $ref.
+* Instead if fetches them and puts them under x-ext, and changes the $ref to point to #x-ext/<name>.
+* This function dereferences those x-ext $ref's.
+*/
+function dereferenceExternalRef(data) {
+	const extensions = data["x-ext"] ?? {};
+	const UNWANTED_KEYS = new Set(["$schema", "$id"]);
+	function scrub(obj) {
+		if (obj === null || obj === void 0) return obj;
+		if (Array.isArray(obj)) return obj.map((x) => scrub(x));
+		if (typeof obj === "object") {
+			const rec = obj;
+			const out = {};
+			for (const [k, v] of Object.entries(rec)) {
+				if (UNWANTED_KEYS.has(k)) continue;
+				out[k] = scrub(v);
+			}
+			return out;
 		}
-	}, payload];
-};
-let githubToken = null;
-const getGithubAcessToken = async (githubTokenPath) => {
-	if (githubToken) return githubToken;
-	if (await fs$1.pathExists(githubTokenPath)) return fs$1.readFile(githubTokenPath, "utf8");
-	else {
-		const answers = await enquirer.prompt([{
-			type: "input",
-			name: "githubToken",
-			message: "Please provide a GitHub token with `repo` rules checked (https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/)"
-		}, {
-			type: "confirm",
-			name: "saveToken",
-			message: "Would you like to store your token for the next time? (stored in your node_modules)"
-		}]);
-		githubToken = answers.githubToken;
-		if (answers.saveToken) await fs$1.outputFile(githubTokenPath, answers.githubToken);
-		return answers.githubToken;
+		return obj;
 	}
-};
-const getGithubOpenApi = async (url) => {
-	const githubTokenPath = upath.join(import.meta.dirname, ".githubToken");
-	const accessToken = await getGithubAcessToken(githubTokenPath);
-	const [info] = url.split("github.com/").slice(-1);
-	const [owner, repo, , branch, ...paths] = info.split("/");
-	const path$1 = paths.join("/");
-	try {
-		const { body } = await request(...getGithubSpecReq({
-			accessToken,
-			repo,
-			owner,
-			branch,
-			path: path$1
-		}));
-		if (body.errors?.length) {
-			if (body.errors?.some((error) => error?.type === "NOT_FOUND")) {
-				if ((await enquirer.prompt([{
-					type: "confirm",
-					name: "removeToken",
-					message: "Your token doesn't have the correct permissions, should we remove it?"
-				}])).removeToken) await fs$1.unlink(githubTokenPath);
+	function replaceRefs(obj) {
+		if (obj === null || obj === void 0) return obj;
+		if (typeof obj === "object") {
+			if (Array.isArray(obj)) return obj.map((element) => replaceRefs(element));
+			const record = obj;
+			if ("$ref" in record && typeof record.$ref === "string") {
+				const refValue = record.$ref;
+				if (refValue.startsWith("#/x-ext/")) {
+					const parts = refValue.replace("#/x-ext/", "").split("/");
+					const extKey = parts.shift();
+					if (extKey) {
+						let refObj = extensions[extKey];
+						for (const p of parts) if (refObj && typeof refObj === "object" && p in refObj) refObj = refObj[p];
+						else {
+							refObj = void 0;
+							break;
+						}
+						if (refObj) return replaceRefs(scrub(refObj));
+					}
+				}
 			}
+			const result$1 = {};
+			for (const [key, value] of Object.entries(record)) result$1[key] = replaceRefs(value);
+			return result$1;
 		}
-		return body.data?.repository?.object.text;
-	} catch (error) {
-		if (!error.body) throw new Error(`Oups... 🍻. ${error}`);
-		if (error.body.message === "Bad credentials") {
-			if ((await enquirer.prompt([{
-				type: "confirm",
-				name: "removeToken",
-				message: "Your token doesn't have the correct permissions, should we remove it?"
-			}])).removeToken) await fs$1.unlink(githubTokenPath);
-		}
-		throw new Error(error.body.message || `Oups... 🍻. ${error}`);
+		return obj;
 	}
-};
-const githubResolver = {
-	order: 199,
-	canRead(file) {
-		return file.url.includes("github.com");
-	},
-	read(file) {
-		return getGithubOpenApi(file.url);
-	}
-};
+	const result = {};
+	for (const [key, value] of Object.entries(data)) if (key !== "x-ext") result[key] = replaceRefs(value);
+	return result;
+}
 
 //#endregion
-//#region src/utils/http-resolver.ts
-const httpResolver = { safeUrlResolver: false };
+//#region src/utils/execute-hook.ts
+const executeHook = async (name$1, commands = [], args = []) => {
+	log(chalk.white(`Running ${name$1} hook...`));
+	for (const command of commands) try {
+		if (isString(command)) await executeCommand(command, args);
+		else if (isFunction(command)) await command(args);
+		else if (isObject(command)) await executeObjectCommand(command, args);
+	} catch (error) {
+		logError(error, `Failed to run ${name$1} hook`);
+	}
+};
+async function executeCommand(command, args) {
+	const [cmd, ..._args] = [...parseArgsStringToArgv(command), ...args];
+	await execa(cmd, _args);
+}
+async function executeObjectCommand(command, args) {
+	if (command.injectGeneratedDirsAndFiles === false) args = [];
+	if (isString(command.command)) await executeCommand(command.command, args);
+	else if (isFunction(command.command)) await command.command();
+}
 
 //#endregion
 //#region src/utils/package-json.ts
@@ -518,7 +407,7 @@ const loadPackageJson = async (packageJson, workspace = process.cwd()) => {
 		return;
 	}
 	const normalizedPath = normalizePath(packageJson, workspace);
-	if (fs$1.existsSync(normalizedPath)) {
+	if (fs.existsSync(normalizedPath)) {
 		const pkg = await dynamicImport(normalizedPath);
 		if (isPackageJson(pkg)) return await maybeReplaceCatalog(pkg, workspace);
 		else throw new Error(`Invalid package.json file: ${normalizedPath}`);
@@ -536,7 +425,7 @@ const maybeReplaceCatalog = async (pkg, workspace) => {
 		log(`⚠️  ${chalk.yellow("package.json contains pnpm catalog: in dependencies, but no pnpm-workspace.yaml was found.")}`);
 		return pkg;
 	}
-	const file = await fs$1.readFile(filePath, "utf8");
+	const file = await fs.readFile(filePath, "utf8");
 	const pnpmWorkspaceFile = yaml.load(file);
 	performSubstitution(pkg.dependencies, pnpmWorkspaceFile);
 	performSubstitution(pkg.devDependencies, pnpmWorkspaceFile);
@@ -582,7 +471,7 @@ const loadTsconfig = async (tsconfig, workspace = process.cwd()) => {
 	}
 	if (isString(tsconfig)) {
 		const normalizedPath = normalizePath(tsconfig, workspace);
-		if (fs$1.existsSync(normalizedPath)) {
+		if (fs.existsSync(normalizedPath)) {
 			const config = await parse(normalizedPath);
 			return config.referenced?.find(({ tsconfigFile }) => tsconfigFile === normalizedPath)?.tsconfig || config.tsconfig;
 		}
@@ -600,7 +489,7 @@ const loadTsconfig = async (tsconfig, workspace = process.cwd()) => {
 function defineConfig(options) {
 	return options;
 }
-const createFormData = (workspace, formData) => {
+function createFormData(workspace, formData) {
 	const defaultArrayHandling = FormDataArrayHandling.SERIALIZE;
 	if (formData === void 0) return {
 		disabled: false,
@@ -625,8 +514,8 @@ const createFormData = (workspace, formData) => {
 		mutator: normalizeMutator(workspace, formData),
 		arrayHandling: defaultArrayHandling
 	};
-};
-const normalizeOptions = async (optionsExport, workspace = process.cwd(), globalOptions = {}) => {
+}
+async function normalizeOptions(optionsExport, workspace = process.cwd(), globalOptions = {}) {
 	const options = await (isFunction(optionsExport) ? optionsExport() : optionsExport);
 	if (!options.input) throw new Error(chalk.red(`Config require an input`));
 	if (!options.output) throw new Error(chalk.red(`Config require an output`));
@@ -659,10 +548,7 @@ const normalizeOptions = async (optionsExport, workspace = process.cwd(), global
 	const normalizedOptions = {
 		input: {
 			target: globalOptions.input ? normalizePathOrUrl(globalOptions.input, process.cwd()) : normalizePathOrUrl(inputOptions.target, workspace),
-			validation: inputOptions.validation || false,
 			override: { transformer: normalizePath(inputOptions.override?.transformer, workspace) },
-			converterOptions: inputOptions.converterOptions ?? {},
-			parserOptions: mergeDeep(parserDefaultOptions, inputOptions.parserOptions ?? {}),
 			filters: inputOptions.filters
 		},
 		output: {
@@ -781,15 +667,8 @@ const normalizeOptions = async (optionsExport, workspace = process.cwd(), global
 	if (!normalizedOptions.input.target) throw new Error(chalk.red(`Config require an input target`));
 	if (!normalizedOptions.output.target && !normalizedOptions.output.schemas) throw new Error(chalk.red(`Config require an output target or schemas`));
 	return normalizedOptions;
-};
-const parserDefaultOptions = {
-	validate: true,
-	resolve: {
-		github: githubResolver,
-		http: httpResolver
-	}
-};
-const normalizeMutator = (workspace, mutator) => {
+}
+function normalizeMutator(workspace, mutator) {
 	if (isObject(mutator)) {
 		if (!mutator.path) throw new Error(chalk.red(`Mutator need a path`));
 		return {
@@ -803,17 +682,17 @@ const normalizeMutator = (workspace, mutator) => {
 		default: true
 	};
 	return mutator;
-};
-const normalizePathOrUrl = (path$1, workspace) => {
+}
+function normalizePathOrUrl(path$1, workspace) {
 	if (isString(path$1) && !isUrl(path$1)) return normalizePath(path$1, workspace);
 	return path$1;
-};
-const normalizePath = (path$1, workspace) => {
+}
+function normalizePath(path$1, workspace) {
 	if (!isString(path$1)) return path$1;
 	return upath.resolve(workspace, path$1);
-};
-const normalizeOperationsAndTags = (operationsOrTags, workspace, global) => {
-	return Object.fromEntries(Object.entries(operationsOrTags).map(([key, { transformer, mutator, formData, formUrlEncoded, paramsSerializer, query: query$1, zod: zod$1,...rest }]) => {
+}
+function normalizeOperationsAndTags(operationsOrTags, workspace, global) {
+	return Object.fromEntries(Object.entries(operationsOrTags).map(([key, { transformer, mutator, formData, formUrlEncoded, paramsSerializer, query: query$1, zod: zod$1, ...rest }]) => {
 		return [key, {
 			...rest,
 			...query$1 ? { query: normalizeQueryOptions(query$1, workspace, global.query) } : {},
@@ -857,16 +736,16 @@ const normalizeOperationsAndTags = (operationsOrTags, workspace, global) => {
 			...paramsSerializer ? { paramsSerializer: normalizeMutator(workspace, paramsSerializer) } : {}
 		}];
 	}));
-};
-const normalizeOutputMode = (mode) => {
+}
+function normalizeOutputMode(mode) {
 	if (!mode) return OutputMode.SINGLE;
 	if (!Object.values(OutputMode).includes(mode)) {
 		createLogger().warn(chalk.yellow(`Unknown the provided mode => ${mode}`));
 		return OutputMode.SINGLE;
 	}
 	return mode;
-};
-const normalizeHooks = (hooks) => {
+}
+function normalizeHooks(hooks) {
 	return Object.keys(hooks).reduce((acc, key) => {
 		if (isString(hooks[key])) return {
 			...acc,
@@ -886,19 +765,19 @@ const normalizeHooks = (hooks) => {
 		};
 		return acc;
 	}, {});
-};
-const normalizeHonoOptions = (hono$1 = {}, workspace) => {
+}
+function normalizeHonoOptions(hono$1 = {}, workspace) {
 	return {
 		...hono$1.handlers ? { handlers: upath.resolve(workspace, hono$1.handlers) } : {},
 		compositeRoute: hono$1.compositeRoute ?? "",
 		validator: hono$1.validator ?? true,
 		validatorOutputPath: hono$1.validatorOutputPath ? upath.resolve(workspace, hono$1.validatorOutputPath) : ""
 	};
-};
-const normalizeJSDocOptions = (jsdoc = {}) => {
+}
+function normalizeJSDocOptions(jsdoc = {}) {
 	return { ...jsdoc };
-};
-const normalizeQueryOptions = (queryOptions = {}, outputWorkspace, globalOptions = {}) => {
+}
+function normalizeQueryOptions(queryOptions = {}, outputWorkspace, globalOptions = {}) {
 	if (queryOptions.options) console.warn("[WARN] Using query options is deprecated and will be removed in a future major release. Please use queryOptions or mutationOptions instead.");
 	return {
 		...isUndefined(queryOptions.usePrefetch) ? {} : { usePrefetch: queryOptions.usePrefetch },
@@ -932,76 +811,66 @@ const normalizeQueryOptions = (queryOptions = {}, outputWorkspace, globalOptions
 		...isUndefined(globalOptions.version) ? {} : { version: globalOptions.version },
 		...isUndefined(queryOptions.version) ? {} : { version: queryOptions.version }
 	};
-};
-const getDefaultFilesHeader = ({ title, description: description$1, version: version$1 } = {}) => [
-	`Generated by ${name} v${version} 🍺`,
-	`Do not edit manually.`,
-	...title ? [title] : [],
-	...description$1 ? [description$1] : [],
-	...version$1 ? [`OpenAPI spec version: ${version$1}`] : []
-];
+}
+function getDefaultFilesHeader({ title, description: description$1, version: version$1 } = {}) {
+	return [
+		`Generated by ${name} v${version} 🍺`,
+		`Do not edit manually.`,
+		...title ? [title] : [],
+		...description$1 ? [description$1] : [],
+		...version$1 ? [`OpenAPI spec version: ${version$1}`] : []
+	];
+}
 
 //#endregion
 //#region src/utils/watcher.ts
-const startWatcher = async (watchOptions, watchFn, defaultTarget = ".") => {
+/**
+* Start a file watcher and invoke an async callback on file changes.
+*
+* If `watchOptions` is falsy the watcher is not started. Supported shapes:
+*  - boolean: when true the `defaultTarget` is watched
+*  - string: a single path to watch
+*  - string[]: an array of paths to watch
+*
+* @param watchOptions - false to disable watching, or a path/paths to watch
+* @param watchFn - async callback executed on change events
+* @param defaultTarget - path(s) to watch when `watchOptions` is `true` (default: '.')
+* @returns Resolves once the watcher has been started (or immediately if disabled)
+*
+* @example
+* await startWatcher(true, async () => { await buildProject(); }, 'src');
+*/
+async function startWatcher(watchOptions, watchFn, defaultTarget = ".") {
 	if (!watchOptions) return;
 	const { watch } = await import("chokidar");
 	const ignored = ["**/{.git,node_modules}/**"];
-	const watchPaths = typeof watchOptions === "boolean" ? defaultTarget : Array.isArray(watchOptions) ? watchOptions.filter((path$1) => typeof path$1 === "string") : watchOptions;
+	const watchPaths = typeof watchOptions === "boolean" ? defaultTarget : watchOptions;
 	log(`Watching for changes in ${Array.isArray(watchPaths) ? watchPaths.map((v) => "\"" + v + "\"").join(" | ") : "\"" + watchPaths + "\""}`);
 	watch(watchPaths, {
 		ignorePermissionErrors: true,
 		ignored
-	}).on("all", async (type, file) => {
+	}).on("all", (type, file) => {
 		log(`Change detected: ${type} ${file}`);
-		try {
-			await watchFn();
-		} catch (error) {
+		watchFn().catch((error) => {
 			logError(error);
-		}
+		});
 	});
-};
-
-//#endregion
-//#region src/utils/execute-hook.ts
-const executeHook = async (name$1, commands = [], args = []) => {
-	log(chalk.white(`Running ${name$1} hook...`));
-	for (const command of commands) try {
-		if (isString(command)) await executeCommand(command, args);
-		else if (isFunction(command)) await command(args);
-		else if (isObject(command)) await executeObjectCommand(command, args);
-	} catch (error) {
-		logError(error, `Failed to run ${name$1} hook`);
-	}
-};
-async function executeCommand(command, args) {
-	const [cmd, ..._args] = [...parseArgsStringToArgv(command), ...args];
-	await execa(cmd, _args);
-}
-async function executeObjectCommand(command, args) {
-	if (command.injectGeneratedDirsAndFiles === false) args = [];
-	if (isString(command.command)) await executeCommand(command.command, args);
-	else if (isFunction(command.command)) await command.command();
 }
 
 //#endregion
 //#region src/write-specs.ts
-const getHeader = (option, info) => {
+function getHeader(option, info) {
 	if (!option) return "";
 	const header = option(info);
 	return Array.isArray(header) ? jsDoc({ description: header }) : header;
-};
-const writeSpecs = async (builder, workspace, options, projectName) => {
+}
+async function writeSpecs(builder, workspace, options, projectName) {
 	const { info = {
 		title: "",
 		version: 0
 	}, schemas, target } = builder;
 	const { output } = options;
 	const projectTitle = projectName ?? info.title;
-	const specsName = Object.keys(schemas).reduce((acc, specKey) => {
-		acc[specKey] = upath.getSpecName(specKey, target).slice(1).split("/").join("-");
-		return acc;
-	}, {});
 	const header = getHeader(output.override.header, info);
 	if (output.schemas) {
 		const rootSchemaPath = output.schemas;
@@ -1009,28 +878,23 @@ const writeSpecs = async (builder, workspace, options, projectName) => {
 			"tags",
 			"tags-split",
 			"split"
-		].includes(output.mode) ? ".ts" : output.fileExtension ?? ".ts";
-		await Promise.all(Object.entries(schemas).map(([specKey, schemas$1]) => {
-			return writeSchemas({
-				schemaPath: isRootKey(specKey, target) ? rootSchemaPath : upath.join(rootSchemaPath, specsName[specKey]),
-				schemas: schemas$1,
-				target,
-				namingConvention: output.namingConvention,
-				fileExtension,
-				specsName,
-				specKey,
-				isRootKey: isRootKey(specKey, target),
-				header,
-				indexFiles: output.indexFiles
-			});
-		}));
+		].includes(output.mode) ? ".ts" : output.fileExtension;
+		await writeSchemas({
+			schemaPath: rootSchemaPath,
+			schemas,
+			target,
+			namingConvention: output.namingConvention,
+			fileExtension,
+			header,
+			indexFiles: output.indexFiles
+		});
 	}
 	let implementationPaths = [];
 	if (output.target) implementationPaths = await getWriteMode(output.mode)({
 		builder,
 		workspace,
 		output,
-		specsName,
+		projectName,
 		header,
 		needSchema: !output.schemas && output.client !== "zod"
 	});
@@ -1040,16 +904,16 @@ const writeSpecs = async (builder, workspace, options, projectName) => {
 		if (output.schemas) imports.push(upath.relativeSafe(workspacePath, getFileInfo(output.schemas).dirname));
 		if (output.indexFiles) {
 			const indexFile = upath.join(workspacePath, "/index.ts");
-			if (await fs$1.pathExists(indexFile)) {
-				const data = await fs$1.readFile(indexFile, "utf8");
+			if (await fs.pathExists(indexFile)) {
+				const data = await fs.readFile(indexFile, "utf8");
 				const importsNotDeclared = imports.filter((imp) => !data.includes(imp));
-				await fs$1.appendFile(indexFile, unique(importsNotDeclared).map((imp) => `export * from '${imp}';\n`).join(""));
-			} else await fs$1.outputFile(indexFile, unique(imports).map((imp) => `export * from '${imp}';`).join("\n") + "\n");
+				await fs.appendFile(indexFile, unique(importsNotDeclared).map((imp) => `export * from '${imp}';\n`).join(""));
+			} else await fs.outputFile(indexFile, unique(imports).map((imp) => `export * from '${imp}';`).join("\n") + "\n");
 			implementationPaths = [indexFile, ...implementationPaths];
 		}
 	}
 	if (builder.extraFiles.length > 0) {
-		await Promise.all(builder.extraFiles.map(async (file) => fs$1.outputFile(file.path, file.content)));
+		await Promise.all(builder.extraFiles.map(async (file) => fs.outputFile(file.path, file.content)));
 		implementationPaths = [...implementationPaths, ...builder.extraFiles.map((file) => file.path)];
 	}
 	const paths = [...output.schemas ? [getFileInfo(output.schemas).dirname] : [], ...implementationPaths];
@@ -1097,8 +961,8 @@ const writeSpecs = async (builder, workspace, options, projectName) => {
 		log(chalk.yellow(message));
 	}
 	createSuccessMessage(projectTitle);
-};
-const getWriteMode = (mode) => {
+}
+function getWriteMode(mode) {
 	switch (mode) {
 		case OutputMode.SPLIT: return writeSplitMode;
 		case OutputMode.TAGS: return writeTagsMode;
@@ -1106,11 +970,22 @@ const getWriteMode = (mode) => {
 		case OutputMode.SINGLE:
 		default: return writeSingleMode;
 	}
-};
+}
 
 //#endregion
-//#region src/generate.ts
-const generateSpec = async (workspace, options, projectName) => {
+//#region src/generate-spec.ts
+/**
+* Generate client/spec files for a single Orval project.
+*
+* @param workspace - Absolute or relative workspace path used to resolve imports.
+* @param options - Normalized generation options for this project.
+* @param projectName - Optional project name used in logging output.
+* @returns A promise that resolves once generation (and optional cleaning) completes.
+*
+* @example
+* await generateSpec(process.cwd(), normalizedOptions, 'my-project');
+*/
+async function generateSpec(workspace, options, projectName) {
 	if (options.output.clean) {
 		const extraPatterns = Array.isArray(options.output.clean) ? options.output.clean : [];
 		if (options.output.target) await removeFilesAndEmptyFolders([
@@ -1123,44 +998,35 @@ const generateSpec = async (workspace, options, projectName) => {
 			"!**/*.d.ts",
 			...extraPatterns
 		], getFileInfo(options.output.schemas).dirname);
-		log(`${projectName ? `${projectName}: ` : ""}Cleaning output folder`);
-	}
-	await writeSpecs(await importSpecs(workspace, options), workspace, options, projectName);
-};
-const generateSpecs = async (config, workspace, projectName) => {
-	if (projectName) {
-		const options = config[projectName];
-		if (options) try {
-			await generateSpec(workspace, options, projectName);
-		} catch (error) {
-			throw new ErrorWithTag(error instanceof Error ? error.message : "unknown error", projectName, { cause: error });
-		}
-		else throw new Error("Project not found");
-		return;
-	}
-	let hasErrors;
-	for (const [projectName$1, options] of Object.entries(config)) {
-		if (!options) {
-			hasErrors = true;
-			logError("No options found", projectName$1);
-			continue;
-		}
-		try {
-			await generateSpec(workspace, options, projectName$1);
-		} catch (error) {
-			hasErrors = true;
-			logError(error, projectName$1);
-		}
+		log(`${projectName} Cleaning output folder`);
 	}
-	if (hasErrors) throw new Error("One or more project failed, see above for details");
-};
+	await writeSpecs(await importSpecs(workspace, options, projectName), workspace, options, projectName);
+}
+
+//#endregion
+//#region src/utils/config.ts
+/**
+* Resolve the Orval config file path.
+*
+* @param configFilePath - Optional path to the config file (absolute or relative).
+* @returns The absolute path to the resolved config file.
+* @throws If a provided path does not exist or if no config file is found.
+*
+* @example
+* // explicit path
+* const p = findConfigFile('./orval.config.ts');
+*
+* @example
+* // automatic discovery (searches process.cwd())
+* const p = findConfigFile();
+*/
 function findConfigFile(configFilePath) {
 	if (configFilePath) {
-		const absolutePath = path.isAbsolute(configFilePath) ? configFilePath : path.resolve(process$1.cwd(), configFilePath);
-		if (!fs.existsSync(absolutePath)) throw new Error(`Config file ${configFilePath} does not exist`);
+		const absolutePath = path.isAbsolute(configFilePath) ? configFilePath : path.resolve(process.cwd(), configFilePath);
+		if (!fs$1.existsSync(absolutePath)) throw new Error(`Config file ${configFilePath} does not exist`);
 		return absolutePath;
 	}
-	const root = process$1.cwd();
+	const root = process.cwd();
 	for (const ext of [
 		".ts",
 		".js",
@@ -1168,34 +1034,26 @@ function findConfigFile(configFilePath) {
 		".mts"
 	]) {
 		const fullPath = path.resolve(root, `orval.config${ext}`);
-		if (fs.existsSync(fullPath)) return fullPath;
+		if (fs$1.existsSync(fullPath)) return fullPath;
 	}
 	throw new Error(`No config file found in ${root}`);
 }
+/**
+* Load an Orval config file
+* @param configFilePath - Path to the config file (absolute or relative).
+* @returns The resolved Orval `Config` object.
+* @throws If the module does not provide a default export or the default export resolves to `undefined`.
+*
+* @example
+* // load a config object
+* const cfg = await loadConfigFile('./orval.config.ts');
+*/
 async function loadConfigFile(configFilePath) {
-	const module = await createJiti(import.meta.url, { interopDefault: true }).import(configFilePath, { default: true });
-	if (module === void 0) throw new Error(`${configFilePath} doesn't have a default export`);
-	return await Promise.resolve(module);
+	const configExternal = await createJiti(process.cwd(), { interopDefault: true }).import(configFilePath, { default: true });
+	if (configExternal === void 0) throw new Error(`${configFilePath} doesn't have a default export`);
+	return await (isFunction(configExternal) ? configExternal() : configExternal);
 }
-const generateConfig = async (configFile, options) => {
-	const configFilePath = findConfigFile(configFile);
-	let configExternal;
-	try {
-		configExternal = await loadConfigFile(configFilePath);
-	} catch (error) {
-		const errorMsg = error instanceof Error ? error.message : "unknown error";
-		throw new Error(`failed to load from ${configFilePath} => ${errorMsg}`);
-	}
-	const workspace = path.dirname(configFilePath);
-	const config = await (isFunction(configExternal) ? configExternal() : configExternal);
-	const normalizedConfig = await asyncReduce(Object.entries(config), async (acc, [key, value]) => {
-		acc[key] = await normalizeOptions(value, workspace, options);
-		return acc;
-	}, {});
-	const fileToWatch = Object.entries(normalizedConfig).filter(([project]) => options?.projectName === void 0 || project === options.projectName).map(([, options$1]) => options$1?.input.target).filter((target) => isString(target));
-	await (options?.watch && fileToWatch.length > 0 ? startWatcher(options.watch, () => generateSpecs(normalizedConfig, workspace, options.projectName), fileToWatch) : generateSpecs(normalizedConfig, workspace, options?.projectName));
-};
 
 //#endregion
-export { normalizeOptions as a, version as c, defineConfig as i, generateSpec as n, description as o, startWatcher as r, name as s, generateConfig as t };
-//# sourceMappingURL=generate-6oT76j_W.js.map
+export { defineConfig as a, name as c, startWatcher as i, version as l, loadConfigFile as n, normalizeOptions as o, generateSpec as r, description as s, findConfigFile as t };
+//# sourceMappingURL=config-CJTbXPiX.mjs.map