@orval/core 8.5.1 → 8.5.2

package/dist/index.d.mts

@@ -8,7 +8,7 @@ import { TypeDocOptions } from "typedoc";
 //#region src/types.d.ts
 interface Options {
   output?: string | OutputOptions;
-  input?: string | InputOptions;
+  input?: string | string[] | InputOptions;
   hooks?: Partial<HooksOptions>;
 }
 type OptionsFn = () => Options | Promise<Options>;
@@ -222,7 +222,7 @@ type InputFiltersOptions = {
   schemas?: (string | RegExp)[];
 };
 type InputOptions = {
-  target: string | Record<string, unknown> | OpenApiDocument;
+  target: string | string[] | Record<string, unknown> | OpenApiDocument;
   override?: OverrideInput;
   filters?: InputFiltersOptions;
   parserOptions?: {
@@ -654,7 +654,7 @@ interface GlobalOptions {
   mode?: OutputMode;
   tsconfig?: string | Tsconfig;
   packageJson?: string;
-  input?: string;
+  input?: string | string[];
   output?: string;
   verbose?: boolean;
 }
@@ -1031,10 +1031,7 @@ type GeneratorClientFooter = (data: {
 type GeneratorClientImports = (data: {
   client: OutputClient | OutputClientFunc;
   implementation: string;
-  imports: {
-    exports: GeneratorImport[];
-    dependency: string;
-  }[];
+  imports: readonly GeneratorDependency[];
   projectName?: string;
   hasSchemaDir: boolean;
   isAllowSyntheticDefaultImports: boolean;
@@ -1046,10 +1043,7 @@ type GeneratorClientImports = (data: {
 }) => string;
 type GenerateMockImports = (data: {
   implementation: string;
-  imports: {
-    exports: GeneratorImport[];
-    dependency: string;
-  }[];
+  imports: readonly GeneratorDependency[];
   projectName?: string;
   hasSchemaDir: boolean;
   isAllowSyntheticDefaultImports: boolean;
@@ -1676,13 +1670,24 @@ declare function resolveObject({
 }: ResolveOptions): ResolverValue;
 //#endregion
 //#region src/resolvers/ref.d.ts
-declare function resolveRef<TSchema extends OpenApiComponentsObject = OpenApiComponentsObject>(schema: OpenApiComponentsObject, context: ContextSpec, imports?: GeneratorImport[]): {
+type Example = OpenApiExampleObject | OpenApiReferenceObject;
+type ResolvedExample = unknown;
+type Examples = Example[] | Record<string, Example> | ResolvedExample[] | Record<string, ResolvedExample> | undefined;
+/**
+ * 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
+ */
+declare function resolveRef<TSchema extends object = OpenApiComponentsObject>(schema: OpenApiComponentsObject | OpenApiReferenceObject, context: ContextSpec, imports?: GeneratorImport[]): {
   schema: TSchema;
   imports: GeneratorImport[];
 };
-type Example = OpenApiExampleObject | OpenApiReferenceObject;
-type Examples = Example[] | Record<string, Example> | undefined;
-declare function resolveExampleRefs(examples: Examples, context: ContextSpec): Examples;
+/** Recursively resolves `$ref` entries in an examples array or record. */
+declare function resolveExampleRefs(examples: Examples, context: ContextSpec): ResolvedExample[] | Record<string, ResolvedExample> | undefined;
 //#endregion
 //#region src/resolvers/value.d.ts
 interface ResolveValueOptions {
@@ -1897,9 +1902,10 @@ declare function mergeDeep<T extends Record<string, unknown>, U extends Record<s
 //#region src/utils/occurrence.d.ts
 declare function count(str: string | undefined, key: string): number;
 declare namespace path_d_exports {
-  export { basename, dirname, extname, getSchemaFileName, isAbsolute, join, joinSafe, normalizeSafe, relativeSafe, resolve, separator$1 as separator };
+  export { getRelativeImportPath, getSchemaFileName, join, joinSafe, normalizeSafe, relativeSafe, separator$1 as separator, toUnix };
 }
-declare const join: (...paths: string[]) => string, resolve: (...paths: string[]) => string, extname: (path: string) => string, dirname: (path: string) => string, basename: (path: string, suffix?: string) => string, isAbsolute: (path: string) => boolean;
+declare function toUnix(value: string): string;
+declare function join(...args: string[]): string;
 /**
  * Behaves exactly like `path.relative(from, to)`, but keeps the first meaningful "./"
  */
@@ -1908,6 +1914,29 @@ declare function getSchemaFileName(path: string): string;
 declare const separator$1 = "/";
 declare function normalizeSafe(value: string): string;
 declare function joinSafe(...values: string[]): string;
+/**
+ * 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.
+ */
+declare function getRelativeImportPath(importerFilePath: string, exporterFilePath: string, includeFileExtension?: boolean): string;
 //#endregion
 //#region src/utils/resolve-version.d.ts
 declare function resolveInstalledVersion(packageName: string, fromDir: string): string | undefined;

package/dist/index.mjs

@@ -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(path.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(path.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(path.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(path.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,6 +722,41 @@ 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 (!path.isAbsolute(importerFilePath)) throw new Error(`'importerFilePath' is not an absolute path. "${importerFilePath}"`);
+	if (!path.isAbsolute(exporterFilePath)) throw new Error(`'exporterFilePath' is not an absolute path. "${exporterFilePath}"`);
+	const importerDir = path.dirname(importerFilePath);
+	const relativePath = path.relative(importerDir, exporterFilePath);
+	let posixPath = path.posix.join(...relativePath.split(path.sep));
+	if (!posixPath.startsWith("./") && !posixPath.startsWith("../")) posixPath = `./${posixPath}`;
+	if (!includeFileExtension) {
+		const ext = path.extname(posixPath);
+		if (ext && posixPath.endsWith(ext)) posixPath = posixPath.slice(0, -ext.length);
+	}
+	return posixPath;
+}
 
 //#endregion
 //#region src/utils/resolve-version.ts
@@ -1174,48 +1201,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 +1286,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 +3180,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 +3277,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 +3294,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,
@@ -3962,8 +4020,8 @@ function getSchema({ schema: { imports, model }, target, header, namingConventio
 	file += model;
 	return file;
 }
-function getPath(path, name, fileExtension) {
-	return join(path, `/${name}${fileExtension}`);
+function getPath(path$1, name, fileExtension) {
+	return path.join(path$1, `${name}${fileExtension}`);
 }
 function writeModelInline(acc, model) {
 	return acc + `${model}\n`;
@@ -4011,7 +4069,7 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 		});
 	}
 	if (indexFiles) {
-		const schemaFilePath = join(schemaPath, `/index${fileExtension}`);
+		const schemaFilePath = path.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)));
@@ -4043,7 +4101,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 +4109,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 +4238,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({
@@ -4248,14 +4306,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 +4338,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 : path.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 +4363,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 = path.join(dirname, implementationFilename);
+		await fs$1.outputFile(implementationPath, implementationData);
+		const mockPath = output.mock ? path.join(dirname, filename + "." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
 		if (mockPath) await fs$1.outputFile(mockPath, mockData);
 		return [
 			implementationPath,
@@ -4444,7 +4502,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 ? path.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 +4510,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 = path.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 +4535,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 : path.join(dirname, filename + ".schemas" + extension);
 			if (schemasPath && needSchema) {
 				const schemasData = header + generateModelsInline(builder.schemas);
 				await fs$1.outputFile(schemasPath, schemasData);
@@ -4517,9 +4576,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 = path.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 ? path.join(dirname, tag, tag + "." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
 			if (mockPath) await fs$1.outputFile(mockPath, mockData);
 			return [
 				implementationPath,
@@ -4543,7 +4602,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 +4612,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 +4638,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 : path.join(dirname, filename + ".schemas" + extension);
 			if (schemasPath && needSchema) {
 				const schemasData = header + generateModelsInline(builder.schemas);
 				await fs$1.outputFile(schemasPath, schemasData);
@@ -4607,7 +4666,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema
 				data += "\n\n";
 				data += implementationMock;
 			}
-			const implementationPath = join(dirname, `${kebab(tag)}${extension}`);
+			const implementationPath = path.join(dirname, `${kebab(tag)}${extension}`);
 			await fs$1.outputFile(implementationPath, data);
 			return [implementationPath, ...schemasPath ? [schemasPath] : []];
 		} catch (error) {