orval 8.16.0 → 8.18.0

package/dist/bin/orval.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { c as description, i as startWatcher, l as name, n as loadConfigFile, r as generateSpec, s as normalizeOptions, t as findConfigFile, u as version } from "../config-4RhXX__A.mjs";
+import { c as description, i as startWatcher, l as name, n as loadConfigFile, r as generateSpec, s as normalizeOptions, t as findConfigFile, u as version } from "../config-CXPetEiJ.mjs";
 import path from "node:path";
 import { Option, program } from "@commander-js/extra-typings";
 import { ErrorWithTag, OutputClient, OutputMode, SupportedFormatter, getWarningCount, isString, log, logError, resetWarnings, setVerbose, startMessage } from "@orval/core";

package/dist/{config-4RhXX__A.mjs → config-CXPetEiJ.mjs}

@@ -28,7 +28,7 @@ import fs$2 from "node:fs";
 import { createJiti } from "jiti";
 //#region package.json
 var name = "orval";
-var version = "8.16.0";
+var version = "8.18.0";
 var description = "A swagger client generator for typescript";
 //#endregion
 //#region src/client.ts
@@ -173,7 +173,8 @@ const generateOperations = (outputClient = DEFAULT_CLIENT, verbsOptions, options
 				type: isFunction(entry) ? OutputMockType.MSW : entry.type,
 				implementation: generated.implementation,
 				imports: generated.imports,
-				strictMockSchemaTypeNames: generated.strictMockSchemaTypeNames
+				strictMockSchemaTypeNames: generated.strictMockSchemaTypeNames,
+				strictMockSchemaKinds: generated.strictMockSchemaKinds
 			};
 		});
 		const hasImplementation = client.implementation.trim().length > 0;
@@ -883,17 +884,27 @@ function createFormData(workspace, formData) {
 function normalizeSchemasOption(schemas, workspace) {
 	if (!schemas) return;
 	if (isString(schemas)) return normalizePath(schemas, workspace);
-	if (schemas.importPath !== void 0 && !schemas.importPath) throw new Error(`schemas.importPath must be a non-empty package specifier (e.g. '@acme/models'). Received an empty string.`);
-	if (schemas.importPath?.trim() === "") throw new Error(`schemas.importPath must be a non-empty package specifier (e.g. '@acme/models'). Received a whitespace-only string.`);
-	if (schemas.importPath && schemas.importPath.trim() !== schemas.importPath) throw new Error(`schemas.importPath must be a non-empty package specifier (e.g. '@acme/models'). Received a value with leading or trailing whitespace: "${schemas.importPath}"`);
-	if (schemas.importPath?.startsWith(".")) throw new Error(`schemas.importPath must be a package specifier (e.g. '@acme/models'), not a relative path. Received: "${schemas.importPath}"`);
-	if (schemas.importPath && (path.isAbsolute(schemas.importPath) || /^[A-Za-z]:[\\/]/.test(schemas.importPath) || schemas.importPath.startsWith("\\\\"))) throw new Error(`schemas.importPath must be a package specifier (e.g. '@acme/models'), not an absolute path. Received: "${schemas.importPath}"`);
+	validatePackageSpecifier(schemas.importPath, "schemas.importPath");
 	return {
 		path: normalizePath(schemas.path, workspace),
-		type: schemas.type,
+		type: schemas.type ?? "typescript",
 		importPath: schemas.importPath
 	};
 }
+/**
+* Validates that a config value is a valid package specifier (bare specifier
+* or sub-path import like `@acme/models` / `@acme/models/fakers`). Rejects
+* empty, whitespace-only, relative (`./`, `../`), and absolute paths with a
+* clear, actionable error message. No-op when the value is `undefined`.
+*/
+function validatePackageSpecifier(value, fieldName) {
+	if (value === void 0) return;
+	if (!value) throw new Error(`\`${fieldName}\` must be a non-empty package specifier (e.g. '@acme/models'). Received an empty string.`);
+	if (value.trim() === "") throw new Error(`\`${fieldName}\` must be a non-empty package specifier (e.g. '@acme/models'). Received a whitespace-only string.`);
+	if (value.trim() !== value) throw new Error(`\`${fieldName}\` must be a non-empty package specifier (e.g. '@acme/models'). Received a value with leading or trailing whitespace: "${value}"`);
+	if (value.startsWith(".")) throw new Error(`\`${fieldName}\` must be a package specifier (e.g. '@acme/models'), not a relative path. Received: "${value}"`);
+	if (path.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\")) throw new Error(`\`${fieldName}\` must be a package specifier (e.g. '@acme/models'), not an absolute path. Received: "${value}"`);
+}
 function normalizeEffectOptions(effect) {
 	return {
 		strict: {
@@ -939,11 +950,14 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 	};
 	else if (mocksOption && typeof mocksOption === "object") {
 		if (!Array.isArray(mocksOption.generators)) throw new TypeError("mock.generators must be an array of generator entries (e.g. [{ type: \"msw\" }]).");
+		const sharedMockPath = mocksOption.path && isString(mocksOption.path) ? normalizePath(mocksOption.path, outputWorkspace) : void 0;
 		mocks = {
 			indexMockFiles: mocksOption.indexMockFiles ?? false,
+			path: sharedMockPath,
 			generators: mocksOption.generators.map((m) => isFunction(m) ? m : {
 				...getDefaultMockOptionsForType(m.type),
-				...m
+				...m,
+				path: m.path && isString(m.path) ? normalizePath(m.path, outputWorkspace) : sharedMockPath
 			})
 		};
 	}
@@ -952,6 +966,7 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 		if (isFunction(entry)) continue;
 		if (seenMockTypes.has(entry.type)) throw new Error(`Duplicate mock generator type "${entry.type}". Each type can only appear once in mock.generators.`);
 		seenMockTypes.add(entry.type);
+		if (entry.type === OutputMockType.FAKER) validatePackageSpecifier(entry.schemasImportPath, "mock.generators[faker].schemasImportPath");
 	}
 	const defaultFileExtension = ".ts";
 	const defaultSchemaFileExtension = !!outputOptions.schemas && (!isString(outputOptions.schemas) && outputOptions.schemas.type === "zod" || isString(outputOptions.schemas) && (outputOptions.client ?? client) === "zod" && outputOptions.override?.zod?.generateReusableSchemas === true) ? ".zod.ts" : defaultFileExtension;
@@ -970,7 +985,7 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 		shouldExportQueryKey: true,
 		shouldFilterQueryKey: false,
 		shouldSplitQueryKey: false,
-		...normalizeQueryOptions(outputOptions.override?.query, workspace)
+		...normalizeQueryOptions(outputOptions.override?.query, outputWorkspace)
 	};
 	const normalizedOptions = {
 		input: {
@@ -1068,13 +1083,13 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 						response: outputOptions.override?.zod?.coerce?.response ?? false
 					},
 					preprocess: {
-						...outputOptions.override?.zod?.preprocess?.param ? { param: normalizeMutator(workspace, outputOptions.override.zod.preprocess.param) } : {},
-						...outputOptions.override?.zod?.preprocess?.query ? { query: normalizeMutator(workspace, outputOptions.override.zod.preprocess.query) } : {},
-						...outputOptions.override?.zod?.preprocess?.header ? { header: normalizeMutator(workspace, outputOptions.override.zod.preprocess.header) } : {},
-						...outputOptions.override?.zod?.preprocess?.body ? { body: normalizeMutator(workspace, outputOptions.override.zod.preprocess.body) } : {},
-						...outputOptions.override?.zod?.preprocess?.response ? { response: normalizeMutator(workspace, outputOptions.override.zod.preprocess.response) } : {}
+						...outputOptions.override?.zod?.preprocess?.param ? { param: normalizeMutator(outputWorkspace, outputOptions.override.zod.preprocess.param) } : {},
+						...outputOptions.override?.zod?.preprocess?.query ? { query: normalizeMutator(outputWorkspace, outputOptions.override.zod.preprocess.query) } : {},
+						...outputOptions.override?.zod?.preprocess?.header ? { header: normalizeMutator(outputWorkspace, outputOptions.override.zod.preprocess.header) } : {},
+						...outputOptions.override?.zod?.preprocess?.body ? { body: normalizeMutator(outputWorkspace, outputOptions.override.zod.preprocess.body) } : {},
+						...outputOptions.override?.zod?.preprocess?.response ? { response: normalizeMutator(outputWorkspace, outputOptions.override.zod.preprocess.response) } : {}
 					},
-					...outputOptions.override?.zod?.params ? { params: normalizeMutator(workspace, outputOptions.override.zod.params) } : {},
+					...outputOptions.override?.zod?.params ? { params: normalizeMutator(outputWorkspace, outputOptions.override.zod.params) } : {},
 					generateEachHttpStatus: outputOptions.override?.zod?.generateEachHttpStatus ?? false,
 					useBrandedTypes: outputOptions.override?.zod?.useBrandedTypes ?? false,
 					generateReusableSchemas: outputOptions.override?.zod?.generateReusableSchemas ?? false,
@@ -1118,6 +1133,11 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 	};
 	if (!normalizedOptions.input.target) throw new Error(styleText("red", `Config requires an input target.`));
 	if (!normalizedOptions.output.target && !normalizedOptions.output.schemas) throw new Error(styleText("red", `Config requires an output target or schemas.`));
+	const fakerWithSchemasImportPath = normalizedOptions.output.mock.generators.find((g) => !isFunction(g) && g.type === OutputMockType.FAKER && !!g.schemasImportPath);
+	if (fakerWithSchemasImportPath) {
+		if (fakerWithSchemasImportPath.schemas !== true) throw new Error(styleText("red", `\`mock.generators[faker].schemasImportPath\` requires \`schemas: true\` on the same generator. Schema-level faker factories are only emitted when \`schemas: true\`.`));
+		if (!(isObject(normalizedOptions.output.schemas) && normalizedOptions.output.schemas.importPath)) throw new Error(styleText("red", `\`mock.generators[faker].schemasImportPath\` requires \`schemas.importPath\` to also be set. It overrides the package specifier used for importing schema-level faker factories.`));
+	}
 	const usesAngularGenerator = normalizedOptions.output.client === OutputClient.ANGULAR || normalizedOptions.output.client === OutputClient.ANGULAR_QUERY && normalizedOptions.output.httpClient === OutputHttpClient.ANGULAR;
 	if (normalizedOptions.output.override.paramsFilter && !usesAngularGenerator) throw new Error(styleText("red", `\`override.paramsFilter\` is only supported by the Angular generator (the \`angular\` client, or \`angular-query\` with \`httpClient: 'angular'\`). It has no effect for other clients — use \`override.paramsSerializer\` instead.`));
 	if (!usesAngularGenerator) {
@@ -1695,8 +1715,8 @@ const groupSchemasByFilePath = (schemas) => {
 	}
 	return [...grouped.values()].map((group) => [...group].toSorted((a, b) => a.filePath.localeCompare(b.filePath, "en", { numeric: true }))).toSorted((a, b) => a[0].filePath.localeCompare(b[0].filePath, "en", { numeric: true }));
 };
-async function writeZodSchemaIndex(schemasPath, fileExtension, header, schemaNames, namingConvention, shouldMergeExisting = false) {
-	const importFileExtension = fileExtension.replace(/\.ts$/, "");
+async function writeZodSchemaIndex(schemasPath, fileExtension, header, schemaNames, namingConvention, shouldMergeExisting = false, tsconfig) {
+	const importFileExtension = getImportExtension(fileExtension, tsconfig);
 	const indexPath = path.join(schemasPath, `index.ts`);
 	let existingExports = "";
 	if (shouldMergeExisting && await fs.pathExists(indexPath)) {
@@ -1803,7 +1823,7 @@ async function writeZodSchemas(builder, schemasPath, fileExtension, header, outp
 		const fileContent = generateZodSchemaFileContent(header, schemaGroup);
 		await fs.outputFile(schemaGroup[0].filePath, fileContent);
 	}
-	if (output.indexFiles) await writeZodSchemaIndex(schemasPath, fileExtension, header, groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName), output.namingConvention, false);
+	if (output.indexFiles) await writeZodSchemaIndex(schemasPath, fileExtension, header, groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName), output.namingConvention, false, output.tsconfig);
 }
 async function writeZodSchemasReusable(builder, schemasPath, fileExtension, header, output, paramsMutator) {
 	const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
@@ -1830,7 +1850,7 @@ async function writeZodSchemasReusable(builder, schemasPath, fileExtension, head
 	for (const entry of rewritten) {
 		const fileName = conventionName(entry.name, output.namingConvention);
 		const filePath = path.join(schemasPath, `${fileName}${fileExtension}`);
-		const importExt = fileExtension.replace(/\.ts$/, "");
+		const importExt = getImportExtension(fileExtension, output.tsconfig);
 		const rendered = renderReusableSchemaEntry(entry, context);
 		const refImports = buildSiblingImports({
 			usedRefs: entry.usedRefs,
@@ -1844,7 +1864,7 @@ async function writeZodSchemasReusable(builder, schemasPath, fileExtension, head
 		const fileContent = `${header}import { z as zod } from 'zod';\n` + (imports ? `${imports}\n\n` : "\n") + `${rendered.content}\n`;
 		await fs.outputFile(filePath, fileContent);
 	}
-	if (output.indexFiles && rewritten.length > 0) await writeZodSchemaIndex(schemasPath, fileExtension, header, rewritten.map((e) => e.name), output.namingConvention, true);
+	if (output.indexFiles && rewritten.length > 0) await writeZodSchemaIndex(schemasPath, fileExtension, header, rewritten.map((e) => e.name), output.namingConvention, true, output.tsconfig);
 }
 async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension, header, output, context) {
 	const zodContext = context;
@@ -1928,7 +1948,7 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 		let importStatements;
 		if (useReusableSchemas && parsedZodDefinition.usedRefs.size > 0) {
 			zodExpression = rewriteSentinelsToDirect(zodExpression);
-			const importExt = fileExtension.replace(/\.ts$/, "");
+			const importExt = getImportExtension(fileExtension, output.tsconfig);
 			importStatements = [...parsedZodDefinition.usedRefs].filter((refName) => refName !== name).toSorted().map((refName) => {
 				return `import { ${refName} } from './${conventionName(refName, output.namingConvention)}${importExt}';`;
 			});
@@ -1946,7 +1966,7 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 		const fileContent = generateZodSchemaFileContent(header, schemaGroup);
 		await fs.outputFile(schemaGroup[0].filePath, fileContent);
 	}
-	if (output.indexFiles && uniqueVerbsSchemas.length > 0) await writeZodSchemaIndex(schemasPath, fileExtension, header, groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName), output.namingConvention, true);
+	if (output.indexFiles && uniqueVerbsSchemas.length > 0) await writeZodSchemaIndex(schemasPath, fileExtension, header, groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName), output.namingConvention, true, output.tsconfig);
 }
 //#endregion
 //#region src/write-specs.ts
@@ -1986,6 +2006,10 @@ function getHeader(option, info) {
 /**
 * Add re-export of operation schemas from the main schemas index file.
 * Handles the case where the index file doesn't exist (no regular schemas).
+*
+* NOTE: `operationSchemasPath` is a directory, so under NodeNext the re-export
+* would need an `/index.js` suffix rather than a bare `.js`. That directory-
+* import case is tracked separately and intentionally left as-is here.
 */
 async function addOperationSchemasReExport(schemaPath, operationSchemasPath, header) {
 	const schemaIndexPath = path.join(schemaPath, `index.ts`);
@@ -2013,7 +2037,7 @@ async function writeFakerSchemaMocks(builder, options, header) {
 	if (!fakerEntry) return;
 	const schemasWithDef = builder.schemas.filter((s) => !!s.schema);
 	if (schemasWithDef.length === 0) return;
-	const { implementation, imports, strictMockSchemaTypeNames } = generateFakerForSchemas(schemasWithDef, {
+	const { implementation, imports, strictMockSchemaTypeNames, strictMockSchemaKinds } = generateFakerForSchemas(schemasWithDef, {
 		spec: builder.spec,
 		target: builder.target,
 		workspace: "",
@@ -2022,7 +2046,8 @@ async function writeFakerSchemaMocks(builder, options, header) {
 	if (!implementation.trim()) return;
 	const finalizedImplementation = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(implementation, {
 		mockOptions: output.override.mock,
-		strictSchemaTypeNames: strictMockSchemaTypeNames
+		strictSchemaTypeNames: strictMockSchemaTypeNames,
+		strictMockSchemaKinds
 	}) : implementation;
 	let filePath;
 	let schemaImportPath;
@@ -2171,7 +2196,11 @@ async function writeSpecs(builder, workspace, options, projectName) {
 		const workspacePath = output.workspace;
 		const indexFile = path.join(workspacePath, "index.ts");
 		const mockExtensions = output.mock.generators.map((g) => getMockFileExtensionByTypeName(g));
-		const imports = implementationPaths.filter((p) => mockExtensions.length === 0 || !mockExtensions.some((ext) => p.endsWith(`.${ext}.ts`))).map((p) => upath.getRelativeImportPath(indexFile, getFileInfo(p).pathWithoutExtension, true));
+		const importExtension = getImportExtension(output.fileExtension, output.tsconfig);
+		const imports = implementationPaths.filter((p) => mockExtensions.length === 0 || !mockExtensions.some((ext) => p.endsWith(`.${ext}.ts`))).map((p) => {
+			const relative = upath.getRelativeImportPath(indexFile, p, true);
+			return (relative.endsWith(output.fileExtension) ? relative.slice(0, -output.fileExtension.length) : relative.replace(/\.[^/.]+$/, "")) + importExtension;
+		});
 		if (output.schemas) {
 			const schemasPath = isString(output.schemas) ? output.schemas : output.schemas.path;
 			imports.push(upath.getRelativeImportPath(indexFile, getFileInfo(schemasPath).dirname));
@@ -2323,4 +2352,4 @@ async function loadConfigFile(configFilePath) {
 //#endregion
 export { defineConfig as a, description as c, startWatcher as i, name as l, loadConfigFile as n, defineTransformer as o, generateSpec as r, normalizeOptions as s, findConfigFile as t, version as u };
 
-//# sourceMappingURL=config-4RhXX__A.mjs.map
+//# sourceMappingURL=config-CXPetEiJ.mjs.map