@orval/core 8.5.1 → 8.5.3

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { t as __exportAll } from "./chunk-C7Uep-_p.mjs";
 import { createRequire } from "node:module";
 import { entries, groupBy, isArray, isBoolean, isBoolean as isBoolean$1, isEmptyish, isFunction, isNullish, isNullish as isNullish$1, isNumber, isString, isString as isString$1, prop, unique, uniqueBy, uniqueWith } from "remeda";
 import { keyword } from "esutils";
-import path from "node:path";
+import nodePath from "node:path";
 import { compare } from "compare-versions";
 import debug from "debug";
 import { pathToFileURL } from "node:url";
@@ -134,7 +134,7 @@ function isReference(obj) {
 	return !isNullish$1(obj) && Object.hasOwn(obj, "$ref");
 }
 function isDirectory(pathValue) {
-	return !path.extname(pathValue);
+	return !nodePath.extname(pathValue);
 }
 function isObject(x) {
 	return Object.prototype.toString.call(x) === "[object Object]";
@@ -461,14 +461,14 @@ async function dynamicImport(toImport, from = process.cwd(), takeDefault = true)
 	if (!toImport) return toImport;
 	try {
 		if (isString(toImport)) {
-			const fileUrl = pathToFileURL(path.resolve(from, toImport));
-			const data = path.extname(fileUrl.href) === ".json" ? await import(fileUrl.href, { with: { type: "json" } }) : await import(fileUrl.href);
+			const fileUrl = pathToFileURL(nodePath.resolve(from, toImport));
+			const data = nodePath.extname(fileUrl.href) === ".json" ? await import(fileUrl.href, { with: { type: "json" } }) : await import(fileUrl.href);
 			if (takeDefault && (isObject(data) || isModule(data)) && data.default) return data.default;
 			return data;
 		}
 		return toImport;
 	} catch (error) {
-		throw new Error(`Oups... 🍻. Path: ${String(toImport)} => ${String(error)}`);
+		throw new Error(`Oups... 🍻. Path: ${String(toImport)} => ${String(error)}`, { cause: error });
 	}
 }
 
@@ -482,14 +482,14 @@ function getExtension(path) {
 //#region src/utils/file.ts
 function getFileInfo(target = "", { backupFilename = "filename", extension = ".ts" } = {}) {
 	const isDir = isDirectory(target);
-	const filePath = isDir ? path.join(target, backupFilename + extension) : target;
+	const filePath = isDir ? nodePath.join(target, backupFilename + extension) : target;
 	return {
 		path: filePath,
 		pathWithoutExtension: filePath.replace(/\.[^/.]+$/, ""),
 		extension,
 		isDirectory: isDir,
-		dirname: path.dirname(filePath),
-		filename: path.basename(filePath, extension.startsWith(".") ? extension : `.${extension}`)
+		dirname: nodePath.dirname(filePath),
+		filename: nodePath.basename(filePath, extension.startsWith(".") ? extension : `.${extension}`)
 	};
 }
 async function removeFilesAndEmptyFolders(patterns, dir) {
@@ -565,7 +565,7 @@ function startMessage({ name, version, description }) {
 	return `🍻 ${styleText(["cyan", "bold"], name)} ${styleText("green", `v${version}`)}${description ? ` - ${description}` : ""}`;
 }
 function logError(err, tag) {
-	let message = "";
+	let message;
 	if (err instanceof Error) {
 		message = (err.message || err.stack) ?? "Unknown error";
 		if (err.cause) {
@@ -678,51 +678,43 @@ function count(str = "", key) {
 //#endregion
 //#region src/utils/path.ts
 var path_exports = /* @__PURE__ */ __exportAll({
-	basename: () => basename,
-	dirname: () => dirname,
-	extname: () => extname,
+	getRelativeImportPath: () => getRelativeImportPath,
 	getSchemaFileName: () => getSchemaFileName,
-	isAbsolute: () => isAbsolute,
 	join: () => join,
 	joinSafe: () => joinSafe,
 	normalizeSafe: () => normalizeSafe,
 	relativeSafe: () => relativeSafe,
-	resolve: () => resolve,
-	separator: () => separator
+	separator: () => separator,
+	toUnix: () => toUnix
 });
-function wrapPathFn(fn) {
-	return (...args) => {
-		const result = fn(...args.map((p) => isStringLike(p) ? toUnix(p) : p));
-		return isStringLike(result) ? toUnix(result) : result;
-	};
+function toUnix(value) {
+	value = value.replaceAll("\\", "/");
+	value = value.replaceAll(/(?<!^)\/+/g, "/");
+	return value;
+}
+function join(...args) {
+	return toUnix(nodePath.join(...args.map((a) => toUnix(a))));
 }
-const path$1 = Object.fromEntries(Object.entries(path).map(([key, value]) => [key, isFunction(value) ? wrapPathFn(value) : value]));
-const { join, resolve, extname, dirname, basename, isAbsolute } = path$1;
 /**
 * Behaves exactly like `path.relative(from, to)`, but keeps the first meaningful "./"
 */
 function relativeSafe(from, to) {
-	return normalizeSafe(`.${separator}${path$1.relative(from, to)}`);
+	return normalizeSafe(`.${separator}${toUnix(nodePath.relative(toUnix(from), toUnix(to)))}`);
 }
 function getSchemaFileName(path) {
 	return path.replace(`.${getExtension(path)}`, "").slice(path.lastIndexOf("/") + 1);
 }
 const separator = "/";
-const toUnix = function(value) {
-	value = value.replaceAll("\\", "/");
-	value = value.replaceAll(/(?<!^)\/+/g, "/");
-	return value;
-};
 function normalizeSafe(value) {
 	let result;
 	value = toUnix(value);
-	result = path$1.normalize(value);
+	result = toUnix(nodePath.normalize(value));
 	if (value.startsWith("./") && !result.startsWith("./") && !result.startsWith("..")) result = "./" + result;
 	else if (value.startsWith("//") && !result.startsWith("//")) result = value.startsWith("//./") ? "//." + result : "/" + result;
 	return result;
 }
 function joinSafe(...values) {
-	let result = path$1.join(...values);
+	let result = toUnix(nodePath.join(...values.map((v) => toUnix(v))));
 	if (values.length > 0) {
 		const firstValue = toUnix(values[0]);
 		if (firstValue.startsWith("./") && !result.startsWith("./") && !result.startsWith("..")) result = "./" + result;
@@ -730,25 +722,60 @@ function joinSafe(...values) {
 	}
 	return result;
 }
+/**
+* Given two absolute file paths, generates a valid ESM relative import path
+* from the 'importer' file to the 'exporter' file.
+*
+* @example
+* ```ts
+* getRelativeImportPath('/path/to/importer.ts', '/path/to/exporter.ts')
+* // => './exporter'
+* getRelativeImportPath('/path/to/importer.ts', '/path/to/sub/exporter.ts')
+* // => './sub/exporter'
+* getRelativeImportPath('/path/to/importer.ts', '/path/sibling/exporter.ts')
+* // => '../sibling/exporter'
+* ```
+*
+* This function handles path normalization, cross-platform separators, and
+* ensures the path is a valid ESM relative specifier (e.g., starts with './').
+*
+* @param importerFilePath - The absolute path of the file that will contain the import statement.
+* @param exporterFilePath - The absolute path of the file being imported.
+* @param [includeFileExtension=false] - Whether the import path should include the file extension, defaults to false.
+* @returns The relative import path string.
+*/
+function getRelativeImportPath(importerFilePath, exporterFilePath, includeFileExtension = false) {
+	if (!nodePath.isAbsolute(importerFilePath)) throw new Error(`'importerFilePath' is not an absolute path. "${importerFilePath}"`);
+	if (!nodePath.isAbsolute(exporterFilePath)) throw new Error(`'exporterFilePath' is not an absolute path. "${exporterFilePath}"`);
+	const importerDir = nodePath.dirname(importerFilePath);
+	const relativePath = nodePath.relative(importerDir, exporterFilePath);
+	let posixPath = nodePath.posix.join(...relativePath.split(nodePath.sep));
+	if (!posixPath.startsWith("./") && !posixPath.startsWith("../")) posixPath = `./${posixPath}`;
+	if (!includeFileExtension) {
+		const ext = nodePath.extname(posixPath);
+		if (ext && posixPath.endsWith(ext)) posixPath = posixPath.slice(0, -ext.length);
+	}
+	return posixPath;
+}
 
 //#endregion
 //#region src/utils/resolve-version.ts
 function resolveInstalledVersion(packageName, fromDir) {
 	try {
-		const require = createRequire(path.join(fromDir, "noop.js"));
+		const require = createRequire(nodePath.join(fromDir, "noop.js"));
 		try {
 			return require(`${packageName}/package.json`).version;
 		} catch (directError) {
 			if (directError instanceof Error && "code" in directError && directError.code === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
 				const entryPath = require.resolve(packageName);
-				let dir = path.dirname(entryPath);
-				while (dir !== path.parse(dir).root) {
-					const pkgPath = path.join(dir, "package.json");
+				let dir = nodePath.dirname(entryPath);
+				while (dir !== nodePath.parse(dir).root) {
+					const pkgPath = nodePath.join(dir, "package.json");
 					if (existsSync(pkgPath)) {
 						const pkgData = JSON.parse(readFileSync(pkgPath, "utf8"));
 						if (pkgData.name === packageName) return pkgData.version;
 					}
-					dir = path.dirname(dir);
+					dir = nodePath.dirname(dir);
 				}
 				return;
 			}
@@ -891,17 +918,19 @@ function getNumberWord(num) {
 	return [...num.toString()].reduce((acc, n) => acc + NUMBERS[n], "");
 }
 /**
-* Escapes a specific character in a string by prefixing it with a backslash.
+* Escapes a specific character in a string by prefixing all of its occurrences with a backslash.
 *
 * @param str - The string to escape, or null.
 * @param char - The character to escape. Defaults to single quote (').
 * @returns The escaped string, or null if the input is null.
 * @example
 * escape("don't") // returns "don\'t"
+* escape("it's John's") // returns "it\'s John\'s"
 * escape('say "hello"', '"') // returns 'say \\"hello\\"'
+* escape("a'''b", "'") // returns "a\'\'\'b"
 */
 function escape(str, char = "'") {
-	return str?.replace(char, `\\${char}`);
+	return str?.replaceAll(char, `\\${char}`);
 }
 /**
 * Escape all characters not included in SingleStringCharacters and
@@ -1174,48 +1203,80 @@ function getRefInfo($ref, context) {
 
 //#endregion
 //#region src/resolvers/ref.ts
+const REF_NOT_FOUND_PREFIX = "Oops... 🍻. Ref not found";
+/**
+* Recursively resolves a `$ref` in an OpenAPI document, following
+* nested schema refs and collecting imports along the way.
+*
+* Handles OpenAPI 3.0 `nullable` and 3.1 type-array hints on direct refs.
+*
+* @see https://spec.openapis.org/oas/v3.0.3#reference-object
+* @see https://spec.openapis.org/oas/v3.1.0#reference-object
+*/
 function resolveRef(schema, context, imports = []) {
-	if ("schema" in schema && schema.schema?.$ref) {
-		const resolvedRef = resolveRef(schema.schema, context, imports);
-		if ("examples" in schema) schema.examples = resolveExampleRefs(schema.examples, context);
-		if ("examples" in resolvedRef.schema) resolvedRef.schema.examples = resolveExampleRefs(resolvedRef.schema.examples, context);
+	const refPath = "$ref" in schema ? schema.$ref : void 0;
+	const nestedSchema = "schema" in schema ? schema.schema : void 0;
+	if (isObject(nestedSchema) && isReference(nestedSchema) && typeof nestedSchema.$ref === "string") {
+		const resolvedRef = resolveRef(nestedSchema, context, imports);
+		if ("examples" in schema) {
+			const schemaWithExamples = schema;
+			schemaWithExamples.examples = resolveExampleRefs(schemaWithExamples.examples, context);
+		}
+		if ("examples" in resolvedRef.schema) {
+			const resolvedWithExamples = resolvedRef.schema;
+			resolvedWithExamples.examples = resolveExampleRefs(resolvedWithExamples.examples, context);
+		}
 		return {
 			schema: {
 				...schema,
 				schema: resolvedRef.schema
 			},
-			imports
+			imports: resolvedRef.imports
 		};
 	}
 	if (isDereferenced(schema)) {
-		if ("examples" in schema) schema.examples = resolveExampleRefs(schema.examples, context);
+		if ("examples" in schema) {
+			const schemaWithExamples = schema;
+			schemaWithExamples.examples = resolveExampleRefs(schemaWithExamples.examples, context);
+		}
 		return {
 			schema,
 			imports
 		};
 	}
+	if (!refPath) throw new Error(`${REF_NOT_FOUND_PREFIX}: missing $ref`);
 	const { currentSchema, refInfo: { name, originalName } } = getSchema$1(schema, context);
-	if (!currentSchema) throw new Error(`Oops... 🍻. Ref not found: ${schema.$ref}`);
+	if (!currentSchema) throw new Error(`${REF_NOT_FOUND_PREFIX}: ${refPath}`);
 	return resolveRef(currentSchema, { ...context }, [...imports, {
 		name,
 		schemaName: originalName
 	}]);
 }
+/**
+* Looks up a schema by its `$ref` path in the spec, applying suffix resolution.
+*
+* Preserves OpenAPI 3.0 `nullable` and 3.1 type-array (`["object", "null"]`)
+* hints from the referencing schema onto the resolved target.
+*
+* @see https://spec.openapis.org/oas/v3.0.3#fixed-fields-18 (nullable)
+* @see https://spec.openapis.org/oas/v3.1.0#schema-object (type as array)
+*/
 function getSchema$1(schema, context) {
+	if (!schema.$ref) throw new Error(`${REF_NOT_FOUND_PREFIX}: missing $ref`);
 	const refInfo = getRefInfo(schema.$ref, context);
 	const { refPaths } = refInfo;
 	let schemaByRefPaths = Array.isArray(refPaths) ? prop(context.spec, ...refPaths) : void 0;
 	schemaByRefPaths ??= context.spec;
 	if (isReference(schemaByRefPaths)) return getSchema$1(schemaByRefPaths, context);
 	let currentSchema = schemaByRefPaths || context.spec;
-	if ("nullable" in schema) {
+	if (isObject(currentSchema) && "nullable" in schema) {
 		const nullable = schema.nullable;
 		currentSchema = {
 			...currentSchema,
 			nullable
 		};
 	}
-	if ("type" in schema && Array.isArray(schema.type)) {
+	if (isObject(currentSchema) && "type" in schema && Array.isArray(schema.type)) {
 		const type = schema.type;
 		currentSchema = {
 			...currentSchema,
@@ -1227,17 +1288,18 @@ function getSchema$1(schema, context) {
 		refInfo
 	};
 }
+/** Recursively resolves `$ref` entries in an examples array or record. */
 function resolveExampleRefs(examples, context) {
 	if (!examples) return;
 	return Array.isArray(examples) ? examples.map((example) => {
-		if (isReference(example)) {
+		if (isObject(example) && isReference(example)) {
 			const { schema } = resolveRef(example, context);
 			return schema.value;
 		}
 		return example;
 	}) : (() => {
 		const result = {};
-		for (const [key, example] of Object.entries(examples)) result[key] = isReference(example) ? resolveRef(example, context).schema.value : example;
+		for (const [key, example] of Object.entries(examples)) result[key] = isObject(example) && isReference(example) ? resolveRef(example, context).schema.value : example;
 		return result;
 	})();
 }
@@ -3120,7 +3182,7 @@ function generateModelsInline(obj) {
 //#region src/generators/mutator-info.ts
 async function getMutatorInfo(filePath, options) {
 	const { root = process.cwd(), namedExport = "default", alias, external, tsconfig } = options ?? {};
-	return parseFile(await bundleFile(root, path.resolve(filePath), alias, external, tsconfig?.compilerOptions), namedExport, getEcmaVersion(tsconfig?.compilerOptions?.target));
+	return parseFile(await bundleFile(root, filePath, alias, external, tsconfig?.compilerOptions), namedExport, getEcmaVersion(tsconfig?.compilerOptions?.target));
 }
 async function bundleFile(root, fileName, alias, external, compilerOptions) {
 	const { text } = (await build({
@@ -3217,10 +3279,8 @@ function getEcmaVersion(target) {
 //#region src/generators/mutator.ts
 const BODY_TYPE_NAME = "BodyType";
 const getImport = (output, mutator) => {
-	const outputFileInfo = getFileInfo(output);
-	const mutatorFileInfo = getFileInfo(mutator.path);
-	const { pathWithoutExtension } = getFileInfo(relativeSafe(outputFileInfo.dirname, mutatorFileInfo.path));
-	return `${pathWithoutExtension}${mutator.extension ?? ""}`;
+	const outputFile = getFileInfo(output).path;
+	return `${getRelativeImportPath(outputFile, mutator.path)}${mutator.extension ?? ""}`;
 };
 async function generateMutator({ output, mutator, name, workspace, tsconfig }) {
 	if (!mutator || !output) return;
@@ -3236,7 +3296,7 @@ async function generateMutator({ output, mutator, name, workspace, tsconfig }) {
 	const errorTypeName = mutator.default ? `${pascal(name)}ErrorType` : "ErrorType";
 	const bodyTypeName = mutator.default ? `${pascal(name)}${BODY_TYPE_NAME}` : BODY_TYPE_NAME;
 	const mutatorInfo = await getMutatorInfo(importPath, {
-		root: path.resolve(workspace),
+		root: workspace,
 		namedExport: mutatorInfoName,
 		alias: mutator.alias,
 		external: mutator.external,
@@ -3911,19 +3971,26 @@ function getSchemaGroups(schemaPath, schemas, namingConvention, fileExtension) {
 }
 function getCanonicalMap(schemaGroups, schemaPath, namingConvention, fileExtension) {
 	const canonicalPathMap = /* @__PURE__ */ new Map();
+	const canonicalNameMap = /* @__PURE__ */ new Map();
 	for (const [key, groupSchemas] of Object.entries(schemaGroups)) {
-		const canonicalPath = getPath(schemaPath, conventionName(groupSchemas[0].name, namingConvention), fileExtension);
-		canonicalPathMap.set(key, {
-			importPath: canonicalPath,
+		const canonicalInfo = {
+			importPath: getPath(schemaPath, conventionName(groupSchemas[0].name, namingConvention), fileExtension),
 			name: groupSchemas[0].name
-		});
+		};
+		canonicalPathMap.set(key, canonicalInfo);
+		for (const schema of groupSchemas) canonicalNameMap.set(schema.name, canonicalInfo);
 	}
-	return canonicalPathMap;
+	return {
+		canonicalPathMap,
+		canonicalNameMap
+	};
 }
-function normalizeCanonicalImportPaths(schemas, canonicalPathMap, schemaPath, namingConvention, fileExtension) {
+function normalizeCanonicalImportPaths(schemas, canonicalPathMap, canonicalNameMap, schemaPath, namingConvention, fileExtension) {
 	for (const schema of schemas) schema.imports = schema.imports.map((imp) => {
+		const canonicalByName = canonicalNameMap.get(imp.name);
 		const resolvedImportKey = resolveImportKey(schemaPath, imp.importPath ?? `./${conventionName(imp.name, namingConvention)}`, fileExtension);
-		const canonical = canonicalPathMap.get(resolvedImportKey);
+		const canonicalByPath = canonicalPathMap.get(resolvedImportKey);
+		const canonical = canonicalByName ?? canonicalByPath;
 		if (!canonical?.importPath) return imp;
 		const importPath = removeFileExtension(relativeSafe(schemaPath, canonical.importPath.replaceAll("\\", "/")), fileExtension);
 		return {
@@ -3963,7 +4030,7 @@ function getSchema({ schema: { imports, model }, target, header, namingConventio
 	return file;
 }
 function getPath(path, name, fileExtension) {
-	return join(path, `/${name}${fileExtension}`);
+	return nodePath.join(path, `${name}${fileExtension}`);
 }
 function writeModelInline(acc, model) {
 	return acc + `${model}\n`;
@@ -3983,12 +4050,13 @@ async function writeSchema({ path, schema, target, namingConvention, fileExtensi
 			namingConvention
 		}));
 	} catch (error) {
-		throw new Error(`Oups... 🍻. An Error occurred while writing schema ${name} => ${String(error)}`);
+		throw new Error(`Oups... 🍻. An Error occurred while writing schema ${name} => ${String(error)}`, { cause: error });
 	}
 }
 async function writeSchemas({ schemaPath, schemas, target, namingConvention, fileExtension, header, indexFiles }) {
 	const schemaGroups = getSchemaGroups(schemaPath, schemas, namingConvention, fileExtension);
-	normalizeCanonicalImportPaths(schemas, getCanonicalMap(schemaGroups, schemaPath, namingConvention, fileExtension), schemaPath, namingConvention, fileExtension);
+	const { canonicalPathMap, canonicalNameMap } = getCanonicalMap(schemaGroups, schemaPath, namingConvention, fileExtension);
+	normalizeCanonicalImportPaths(schemas, canonicalPathMap, canonicalNameMap, schemaPath, namingConvention, fileExtension);
 	for (const groupSchemas of Object.values(schemaGroups)) {
 		if (groupSchemas.length === 1) {
 			await writeSchema({
@@ -4011,7 +4079,7 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 		});
 	}
 	if (indexFiles) {
-		const schemaFilePath = join(schemaPath, `/index${fileExtension}`);
+		const schemaFilePath = nodePath.join(schemaPath, `index${fileExtension}`);
 		await fs$1.ensureFile(schemaFilePath);
 		const ext = fileExtension.endsWith(".ts") ? fileExtension.slice(0, -3) : fileExtension;
 		const conventionNamesSet = new Set(Object.values(schemaGroups).map((group) => conventionName(group[0].name, namingConvention)));
@@ -4025,7 +4093,7 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 			const fileContent = `${header}\n${[...new Set([...existingExports, ...currentExports])].toSorted((a, b) => a.localeCompare(b)).join("\n")}`;
 			await fs$1.writeFile(schemaFilePath, fileContent, { encoding: "utf8" });
 		} catch (error) {
-			throw new Error(`Oups... 🍻. An Error occurred while writing schema index file ${schemaFilePath} => ${String(error)}`);
+			throw new Error(`Oups... 🍻. An Error occurred while writing schema index file ${schemaFilePath} => ${String(error)}`, { cause: error });
 		}
 	}
 }
@@ -4034,7 +4102,7 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 //#region src/writers/generate-imports-for-builder.ts
 function generateImportsForBuilder(output, imports, relativeSchemasPath) {
 	const isZodSchemaOutput = isObject(output.schemas) && output.schemas.type === "zod";
-	let schemaImports = [];
+	let schemaImports;
 	if (output.indexFiles) schemaImports = isZodSchemaOutput ? [{
 		exports: imports.filter((i) => !i.importPath),
 		dependency: joinSafe(relativeSchemasPath, "index.zod")
@@ -4043,7 +4111,7 @@ function generateImportsForBuilder(output, imports, relativeSchemasPath) {
 		dependency: relativeSchemasPath
 	}];
 	else schemaImports = uniqueBy(imports.filter((i) => !i.importPath), (x) => x.name).map((i) => {
-		const name = conventionName(i.schemaName ?? i.name, output.namingConvention);
+		const name = conventionName(isZodSchemaOutput ? i.name : i.schemaName ?? i.name, output.namingConvention);
 		const suffix = isZodSchemaOutput ? ".zod" : "";
 		const importExtension = output.fileExtension.replace(/\.ts$/, "") || "";
 		return {
@@ -4051,7 +4119,7 @@ function generateImportsForBuilder(output, imports, relativeSchemasPath) {
 			dependency: joinSafe(relativeSchemasPath, `${name}${suffix}${importExtension}`)
 		};
 	});
-	const otherImports = uniqueBy(imports.filter((i) => !!i.importPath), (x) => x.name + (x.importPath ?? "")).map((i) => {
+	const otherImports = uniqueBy(imports.filter((i) => !!i.importPath), (x) => x.name + x.importPath).map((i) => {
 		return {
 			exports: [i],
 			dependency: i.importPath
@@ -4180,13 +4248,13 @@ interface TypedResponse<T> extends Response {
 //#region src/writers/single-mode.ts
 async function writeSingleMode({ builder, output, projectName, header, needSchema }) {
 	try {
-		const { path, dirname } = getFileInfo(output.target, {
+		const { path } = getFileInfo(output.target, {
 			backupFilename: conventionName(builder.info.title, output.namingConvention),
 			extension: output.fileExtension
 		});
 		const { imports, importsMock, implementation, implementationMock, mutators, clientMutators, formData, formUrlEncoded, paramsSerializer, fetchReviver } = generateTarget(builder, output);
 		let data = header;
-		const schemasPath = output.schemas ? relativeSafe(dirname, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : void 0;
+		const schemasPath = output.schemas ? getRelativeImportPath(path, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : void 0;
 		const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
 		const importsForBuilder = schemasPath ? generateImportsForBuilder(output, imports.filter((imp) => !importsMock.some((impMock) => imp.name === impMock.name)), schemasPath) : [];
 		data += builder.imports({
@@ -4240,7 +4308,7 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 		return [path];
 	} catch (error) {
 		const errorMsg = error instanceof Error ? error.message : "unknown error";
-		throw new Error(`Oups... 🍻. An Error occurred while writing file => ${errorMsg}`);
+		throw new Error(`Oups... 🍻. An Error occurred while writing file => ${errorMsg}`, { cause: error });
 	}
 }
 
@@ -4248,14 +4316,14 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 //#region src/writers/split-mode.ts
 async function writeSplitMode({ builder, output, projectName, header, needSchema }) {
 	try {
-		const { filename, dirname, extension } = getFileInfo(output.target, {
+		const { path: targetPath, filename, dirname, extension } = getFileInfo(output.target, {
 			backupFilename: conventionName(builder.info.title, output.namingConvention),
 			extension: output.fileExtension
 		});
 		const { imports, implementation, implementationMock, importsMock, mutators, clientMutators, formData, formUrlEncoded, paramsSerializer, fetchReviver } = generateTarget(builder, output);
 		let implementationData = header;
 		let mockData = header;
-		const relativeSchemasPath = output.schemas ? relativeSafe(dirname, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas";
+		const relativeSchemasPath = output.schemas ? getRelativeImportPath(targetPath, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas";
 		const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
 		const importsForBuilder = generateImportsForBuilder(output, imports, relativeSchemasPath);
 		implementationData += builder.imports({
@@ -4280,10 +4348,10 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 			isAllowSyntheticDefaultImports,
 			options: isFunction(output.mock) ? void 0 : output.mock
 		});
-		const schemasPath = output.schemas ? void 0 : join(dirname, filename + ".schemas" + extension);
+		const schemasPath = output.schemas ? void 0 : nodePath.join(dirname, filename + ".schemas" + extension);
 		if (schemasPath && needSchema) {
 			const schemasData = header + generateModelsInline(builder.schemas);
-			await fs$1.outputFile(join(dirname, filename + ".schemas" + extension), schemasData);
+			await fs$1.outputFile(schemasPath, schemasData);
 		}
 		if (mutators) implementationData += generateMutatorImports({
 			mutators,
@@ -4305,9 +4373,9 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 		implementationData += `\n${implementation}`;
 		mockData += `\n${implementationMock}`;
 		const implementationFilename = filename + (OutputClient.ANGULAR === output.client ? ".service" : "") + extension;
-		const implementationPath = join(dirname, implementationFilename);
-		await fs$1.outputFile(join(dirname, implementationFilename), implementationData);
-		const mockPath = output.mock ? join(dirname, filename + "." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
+		const implementationPath = nodePath.join(dirname, implementationFilename);
+		await fs$1.outputFile(implementationPath, implementationData);
+		const mockPath = output.mock ? nodePath.join(dirname, filename + "." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
 		if (mockPath) await fs$1.outputFile(mockPath, mockData);
 		return [
 			implementationPath,
@@ -4315,7 +4383,7 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 			...mockPath ? [mockPath] : []
 		];
 	} catch (error) {
-		throw new Error(`Oups... 🍻. An Error occurred while splitting => ${String(error)}`);
+		throw new Error(`Oups... 🍻. An Error occurred while splitting => ${String(error)}`, { cause: error });
 	}
 }
 
@@ -4444,7 +4512,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 	const target = generateTargetForTags(builder, output);
 	const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
 	const mockOption = output.mock && !isFunction(output.mock) ? output.mock : void 0;
-	const indexFilePath = mockOption?.indexMockFiles ? join(dirname, "index." + getMockFileExtensionByTypeName(mockOption) + extension) : void 0;
+	const indexFilePath = mockOption?.indexMockFiles ? nodePath.join(dirname, "index." + getMockFileExtensionByTypeName(mockOption) + extension) : void 0;
 	if (indexFilePath) await fs$1.outputFile(indexFilePath, "");
 	const tagEntries = Object.entries(target);
 	const generatedFilePathsArray = await Promise.all(tagEntries.map(async ([tag, target]) => {
@@ -4452,7 +4520,8 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 			const { imports, implementation, implementationMock, importsMock, mutators, clientMutators, formData, fetchReviver, formUrlEncoded, paramsSerializer } = target;
 			let implementationData = header;
 			let mockData = header;
-			const relativeSchemasPath = output.schemas ? "../" + relativeSafe(dirname, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "../" + filename + ".schemas";
+			const importerPath = nodePath.join(dirname, tag, tag + extension);
+			const relativeSchemasPath = output.schemas ? getRelativeImportPath(importerPath, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "../" + filename + ".schemas";
 			const importsForBuilder = generateImportsForBuilder(output, imports, relativeSchemasPath);
 			implementationData += builder.imports({
 				client: output.client,
@@ -4476,7 +4545,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 				isAllowSyntheticDefaultImports,
 				options: isFunction(output.mock) ? void 0 : output.mock
 			});
-			const schemasPath = output.schemas ? void 0 : join(dirname, filename + ".schemas" + extension);
+			const schemasPath = output.schemas ? void 0 : nodePath.join(dirname, filename + ".schemas" + extension);
 			if (schemasPath && needSchema) {
 				const schemasData = header + generateModelsInline(builder.schemas);
 				await fs$1.outputFile(schemasPath, schemasData);
@@ -4517,9 +4586,9 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 			implementationData += `\n${implementation}`;
 			mockData += `\n${implementationMock}`;
 			const implementationFilename = tag + (OutputClient.ANGULAR === output.client ? ".service" : "") + extension;
-			const implementationPath = join(dirname, tag, implementationFilename);
+			const implementationPath = nodePath.join(dirname, tag, implementationFilename);
 			await fs$1.outputFile(implementationPath, implementationData);
-			const mockPath = output.mock ? join(dirname, tag, tag + "." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
+			const mockPath = output.mock ? nodePath.join(dirname, tag, tag + "." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
 			if (mockPath) await fs$1.outputFile(mockPath, mockData);
 			return [
 				implementationPath,
@@ -4527,7 +4596,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 				...mockPath ? [mockPath] : []
 			];
 		} catch (error) {
-			throw new Error(`Oups... 🍻. An Error occurred while splitting tag ${tag} => ${String(error)}`);
+			throw new Error(`Oups... 🍻. An Error occurred while splitting tag ${tag} => ${String(error)}`, { cause: error });
 		}
 	}));
 	if (indexFilePath && mockOption) {
@@ -4543,7 +4612,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 //#endregion
 //#region src/writers/tags-mode.ts
 async function writeTagsMode({ builder, output, projectName, header, needSchema }) {
-	const { filename, dirname, extension } = getFileInfo(output.target, {
+	const { path: targetPath, filename, dirname, extension } = getFileInfo(output.target, {
 		backupFilename: conventionName(builder.info.title, output.namingConvention),
 		extension: output.fileExtension
 	});
@@ -4553,7 +4622,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema
 		try {
 			const { imports, implementation, implementationMock, importsMock, mutators, clientMutators, formData, formUrlEncoded, fetchReviver, paramsSerializer } = target;
 			let data = header;
-			const schemasPathRelative = output.schemas ? relativeSafe(dirname, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas";
+			const schemasPathRelative = output.schemas ? getRelativeImportPath(targetPath, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas";
 			const importsForBuilder = generateImportsForBuilder(output, imports.filter((imp) => !importsMock.some((impMock) => imp.name === impMock.name)), schemasPathRelative);
 			data += builder.imports({
 				client: output.client,
@@ -4579,7 +4648,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema
 					options: isFunction(output.mock) ? void 0 : output.mock
 				});
 			}
-			const schemasPath = output.schemas ? void 0 : join(dirname, filename + ".schemas" + extension);
+			const schemasPath = output.schemas ? void 0 : nodePath.join(dirname, filename + ".schemas" + extension);
 			if (schemasPath && needSchema) {
 				const schemasData = header + generateModelsInline(builder.schemas);
 				await fs$1.outputFile(schemasPath, schemasData);
@@ -4607,11 +4676,11 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema
 				data += "\n\n";
 				data += implementationMock;
 			}
-			const implementationPath = join(dirname, `${kebab(tag)}${extension}`);
+			const implementationPath = nodePath.join(dirname, `${kebab(tag)}${extension}`);
 			await fs$1.outputFile(implementationPath, data);
 			return [implementationPath, ...schemasPath ? [schemasPath] : []];
 		} catch (error) {
-			throw new Error(`Oups... 🍻. An Error occurred while writing tag ${tag} => ${String(error)}`);
+			throw new Error(`Oups... 🍻. An Error occurred while writing tag ${tag} => ${String(error)}`, { cause: error });
 		}
 	}))).flat();
 }