swagger-typescript-api 13.2.18 → 13.3.0

package/dist/{generate-templates-C4JBmSNw.cjs → generate-templates-BlSkwa8l.cjs}

@@ -39,6 +39,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 let consola = require("consola");
+consola = __toESM(consola);
 let es_toolkit = require("es-toolkit");
 es_toolkit = __toESM(es_toolkit);
 let es_toolkit_compat = require("es-toolkit/compat");
@@ -50,19 +51,22 @@ node_path = __toESM(node_path);
 let _biomejs_js_api = require("@biomejs/js-api");
 let nanoid = require("nanoid");
 nanoid = __toESM(nanoid);
+let yummies_type_guard = require("yummies/type-guard");
 let node_crypto = require("node:crypto");
 node_crypto = __toESM(node_crypto);
 let swagger2openapi = require("swagger2openapi");
 swagger2openapi = __toESM(swagger2openapi);
 let yaml = require("yaml");
 yaml = __toESM(yaml);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let _apidevtools_swagger_parser = require("@apidevtools/swagger-parser");
+_apidevtools_swagger_parser = __toESM(_apidevtools_swagger_parser);
 let node_module = require("node:module");
 node_module = __toESM(node_module);
 let node_url = require("node:url");
 node_url = __toESM(node_url);
 let eta = require("eta");
-let node_fs = require("node:fs");
-node_fs = __toESM(node_fs);
 
 //#region src/code-formatter.ts
 var CodeFormatter = class {
@@ -223,7 +227,7 @@ var ComponentTypeNameResolver = class extends NameResolver {
 //#endregion
 //#region package.json
 var name = "swagger-typescript-api";
-var version = "13.2.18";
+var version = "13.3.0";
 var description = "Generate the API client for Fetch or Axios from an OpenAPI Specification";
 
 //#endregion
@@ -384,6 +388,7 @@ var CodeGenConfig = class {
 		onFormatTypeName: (_typeName, _rawTypeName, _schemaType) => {},
 		onFormatRouteName: (_routeInfo, _templateRouteName) => {}
 	};
+	resolvedSwaggerSchema;
 	defaultResponseType;
 	singleHttpClient = false;
 	httpClientType = HTTP_CLIENT.FETCH;
@@ -639,11 +644,16 @@ var CodeGenConfig = class {
 	};
 };
 
+//#endregion
+//#region src/util/pascal-case.ts
+function pascalCase(value) {
+	return (0, es_toolkit_compat.upperFirst)((0, es_toolkit_compat.camelCase)(value));
+}
+
 //#endregion
 //#region src/schema-components-map.ts
 var SchemaComponentsMap = class {
 	_data = [];
-	config;
 	constructor(config) {
 		this.config = config;
 	}
@@ -656,18 +666,27 @@ var SchemaComponentsMap = class {
 	parseRef = (ref) => {
 		return ref.split("/");
 	};
-	createComponent($ref, rawTypeData) {
+	createComponentDraft($ref, rawTypeData) {
+		if (yummies_type_guard.typeGuard.isObject(rawTypeData) && rawTypeData.typeName && rawTypeData.rawTypeData && rawTypeData.$ref) return rawTypeData;
 		const parsed = this.parseRef($ref);
-		const componentSchema = {
+		const [, rawPointer = ""] = $ref.split("#");
+		const pointerParts = (rawPointer.startsWith("/") ? rawPointer : `/${rawPointer}`).split("/").filter(Boolean);
+		const typeName = pointerParts.at(-1) || parsed.at(-1) || "Unknown";
+		const rawComponentName = pointerParts.at(-2) || parsed[parsed.length - 2] || "schemas";
+		return {
 			$ref,
-			typeName: parsed[parsed.length - 1],
+			typeName,
 			rawTypeData,
-			componentName: parsed[parsed.length - 2],
+			componentName: rawComponentName === "definitions" ? "schemas" : rawComponentName,
 			typeData: null
 		};
+	}
+	createComponent($ref, rawTypeData, addAtStart) {
+		const componentSchema = this.createComponentDraft($ref, rawTypeData);
 		const usageComponent = this.config.hooks.onCreateComponent(componentSchema) || componentSchema;
 		const refIndex = this._data.findIndex((c) => c.$ref === $ref);
-		if (refIndex === -1) this._data.push(usageComponent);
+		if (refIndex === -1) if (addAtStart) this._data.unshift(usageComponent);
+		else this._data.push(usageComponent);
 		else this._data[refIndex] = usageComponent;
 		return usageComponent;
 	}
@@ -678,7 +697,19 @@ var SchemaComponentsMap = class {
 		return this._data.filter((it) => componentNames.some((componentName) => it.$ref.startsWith(`#/components/${componentName}`)));
 	}
 	get = ($ref) => {
-		return this._data.find((c) => c.$ref === $ref) || null;
+		const localFound = this._data.find((c) => c.$ref === $ref) || null;
+		if (localFound != null) return localFound;
+		const { resolvedSwaggerSchema } = this.config;
+		if (resolvedSwaggerSchema.isLocalRef($ref)) return null;
+		const foundByRef = resolvedSwaggerSchema.getRef($ref);
+		const refDetails = resolvedSwaggerSchema.getRefDetails($ref);
+		if (foundByRef != null) {
+			const componentDraft = this.createComponentDraft($ref, foundByRef);
+			componentDraft.typeName = this.config.hooks.onFormatExternalTypeName?.(componentDraft.typeName, refDetails) || componentDraft.typeName;
+			if (this._data.some((component) => component.typeName === componentDraft.typeName)) componentDraft.typeName = this.config.hooks.onFixDuplicateExternalTypeName?.(componentDraft.typeName, refDetails, this._data.map((it) => it.typeName)) ?? `${pascalCase(refDetails.externalOpenapiFileName || "External")}${componentDraft.typeName}`;
+			return this.createComponent($ref, componentDraft);
+		}
+		return null;
 	};
 	enumsFirst() {
 		this._data.sort((a, b) => {
@@ -1336,7 +1367,6 @@ var SchemaParser = class {
 	schemaFormatters;
 	schemaUtils;
 	templatesWorker;
-	schemaWalker;
 	typeName;
 	schema;
 	schemaPath;
@@ -1346,7 +1376,6 @@ var SchemaParser = class {
 		this.templatesWorker = schemaParserFabric.templatesWorker;
 		this.schemaComponentsMap = schemaParserFabric.schemaComponentsMap;
 		this.typeNameFormatter = schemaParserFabric.typeNameFormatter;
-		this.schemaWalker = schemaParserFabric.schemaWalker;
 		this.schemaFormatters = schemaParserFabric.schemaFormatters;
 		this.schemaUtils = schemaParserFabric.schemaUtils;
 		this.typeName = typeName || null;
@@ -1441,24 +1470,13 @@ var SchemaParser = class {
 	};
 };
 
-//#endregion
-//#region src/util/pascal-case.ts
-function pascalCase(value) {
-	return (0, es_toolkit_compat.upperFirst)((0, es_toolkit_compat.camelCase)(value));
-}
-
 //#endregion
 //#region src/schema-parser/schema-utils.ts
 var SchemaUtils = class {
-	config;
-	schemaComponentsMap;
-	typeNameFormatter;
-	schemaWalker;
-	constructor({ config, schemaComponentsMap, typeNameFormatter, schemaWalker }) {
+	constructor(config, schemaComponentsMap, typeNameFormatter) {
 		this.config = config;
 		this.schemaComponentsMap = schemaComponentsMap;
 		this.typeNameFormatter = typeNameFormatter;
-		this.schemaWalker = schemaWalker;
 	}
 	getRequiredProperties = (schema) => {
 		return (0, es_toolkit.uniq)(schema && Array.isArray(schema.required) && schema.required || []);
@@ -1604,14 +1622,12 @@ var SchemaParserFabric = class {
 	schemaFormatters;
 	templatesWorker;
 	schemaUtils;
-	schemaWalker;
-	constructor(config, templatesWorker, schemaComponentsMap, typeNameFormatter, schemaWalker) {
+	constructor(config, templatesWorker, schemaComponentsMap, typeNameFormatter) {
 		this.config = config;
 		this.schemaComponentsMap = schemaComponentsMap;
 		this.typeNameFormatter = typeNameFormatter;
 		this.templatesWorker = templatesWorker;
-		this.schemaWalker = schemaWalker;
-		this.schemaUtils = new SchemaUtils(this);
+		this.schemaUtils = new SchemaUtils(this.config, this.schemaComponentsMap, this.typeNameFormatter);
 		this.schemaFormatters = new SchemaFormatters(this);
 	}
 	createSchemaParser = ({ schema, typeName, schemaPath }) => {
@@ -1696,12 +1712,7 @@ const CONTENT_KIND = {
 	TEXT: "TEXT"
 };
 var SchemaRoutes = class {
-	config;
-	schemaParserFabric;
 	schemaUtils;
-	typeNameFormatter;
-	schemaComponentsMap;
-	templatesWorker;
 	FORM_DATA_TYPES = [];
 	routes = [];
 	hasSecurityRoutes = false;
@@ -1710,10 +1721,10 @@ var SchemaRoutes = class {
 	constructor(config, schemaParserFabric, schemaComponentsMap, templatesWorker, typeNameFormatter) {
 		this.config = config;
 		this.schemaParserFabric = schemaParserFabric;
-		this.schemaUtils = this.schemaParserFabric.schemaUtils;
-		this.typeNameFormatter = typeNameFormatter;
 		this.schemaComponentsMap = schemaComponentsMap;
 		this.templatesWorker = templatesWorker;
+		this.typeNameFormatter = typeNameFormatter;
+		this.schemaUtils = this.schemaParserFabric.schemaUtils;
 		this.FORM_DATA_TYPES = (0, es_toolkit.uniq)([this.schemaUtils.getSchemaType({
 			type: "string",
 			format: "file"
@@ -1722,11 +1733,16 @@ var SchemaRoutes = class {
 			format: "binary"
 		})]);
 	}
-	createRequestsMap = (routesByMethod) => {
+	createRequestsMap = (resolvedSwaggerSchema, routesByMethod) => {
 		const parameters = (0, es_toolkit_compat.get)(routesByMethod, "parameters");
 		const result = {};
 		for (const [method, requestInfo] of Object.entries(routesByMethod)) {
-			if (method.startsWith("x-") || ["parameters", "$ref"].includes(method)) continue;
+			if (method.startsWith("x-") || ["parameters"].includes(method)) continue;
+			if (method === "$ref") {
+				const refData = resolvedSwaggerSchema.getRef(requestInfo);
+				if (yummies_type_guard.typeGuard.isObject(refData)) Object.assign(result, this.createRequestsMap(resolvedSwaggerSchema, refData));
+				continue;
+			}
 			result[method] = {
 				...requestInfo,
 				parameters: (0, es_toolkit.compact)([...parameters || [], ...requestInfo.parameters || []])
@@ -1795,7 +1811,7 @@ var SchemaRoutes = class {
 		for (const parameter of parameters || []) {
 			const refTypeInfo = this.schemaParserFabric.schemaUtils.getSchemaRefType(parameter);
 			let routeParam = null;
-			if (refTypeInfo?.rawTypeData.in && refTypeInfo.rawTypeData) {
+			if (!!refTypeInfo?.rawTypeData && typeof refTypeInfo === "object" && refTypeInfo?.rawTypeData.in) {
 				if (!routeParams[refTypeInfo.rawTypeData.in]) routeParams[refTypeInfo.rawTypeData.in] = [];
 				routeParam = {
 					...refTypeInfo.rawTypeData,
@@ -1865,10 +1881,11 @@ var SchemaRoutes = class {
 		}
 		return defaultType || this.config.Ts.Keyword.Any;
 	};
-	getRequestInfoTypes = ({ requestInfos, parsedSchemas, operationId, defaultType }) => {
+	getRequestInfoTypes = ({ requestInfos, parsedSchemas, operationId, defaultType, resolvedSwaggerSchema }) => {
 		const result = [];
 		for (const [status, requestInfo] of Object.entries(requestInfos || {})) {
 			const contentTypes = this.getContentTypes([requestInfo], operationId);
+			const links = this.getRouteLinksFromResponse(resolvedSwaggerSchema, requestInfo, status);
 			result.push({
 				...requestInfo || {},
 				contentTypes,
@@ -1880,21 +1897,48 @@ var SchemaRoutes = class {
 					defaultType
 				})),
 				description: this.schemaParserFabric.schemaFormatters.formatDescription(requestInfo.description || "", true),
+				links,
 				status: Number.isNaN(+status) ? status : +status,
 				isSuccess: this.isSuccessStatus(status)
 			});
 		}
 		return result;
 	};
-	getResponseBodyInfo = (routeInfo, parsedSchemas) => {
+	getRouteLinksFromResponse = (resolvedSwaggerSchema, responseInfo, status) => {
+		const links = (0, es_toolkit_compat.get)(responseInfo, "links");
+		if (!yummies_type_guard.typeGuard.isObject(links)) return [];
+		return (0, es_toolkit_compat.reduce)(links, (acc, linkInfo, linkName) => {
+			if (!yummies_type_guard.typeGuard.isObject(linkInfo)) return acc;
+			let normalizedLinkInfo = linkInfo;
+			if (typeof linkInfo.$ref === "string") {
+				const refData = resolvedSwaggerSchema.getRef(linkInfo.$ref);
+				if (yummies_type_guard.typeGuard.isObject(refData)) normalizedLinkInfo = refData;
+			}
+			const operationId = typeof normalizedLinkInfo.operationId === "string" ? normalizedLinkInfo.operationId : void 0;
+			const operationRef = typeof normalizedLinkInfo.operationRef === "string" ? normalizedLinkInfo.operationRef : typeof linkInfo.$ref === "string" ? linkInfo.$ref : void 0;
+			if (!operationId && !operationRef) return acc;
+			const parameters = yummies_type_guard.typeGuard.isObject(normalizedLinkInfo.parameters) ? (0, es_toolkit.mapValues)(normalizedLinkInfo.parameters, (value) => String(value)) : void 0;
+			acc.push({
+				status: Number.isNaN(+status) ? status : +status,
+				name: String(linkName),
+				operationId,
+				operationRef,
+				parameters
+			});
+			return acc;
+		}, []);
+	};
+	getResponseBodyInfo = (routeInfo, parsedSchemas, resolvedSwaggerSchema) => {
 		const { produces, operationId, responses } = routeInfo;
 		const contentTypes = this.getContentTypes(responses, [...produces || [], routeInfo["x-accepts"]]);
 		const responseInfos = this.getRequestInfoTypes({
 			requestInfos: responses,
 			parsedSchemas,
 			operationId,
-			defaultType: this.config.defaultResponseType
+			defaultType: this.config.defaultResponseType,
+			resolvedSwaggerSchema
 		});
+		const links = responseInfos.flatMap((responseInfo) => responseInfo.links || []);
 		const successResponse = responseInfos.find((response) => response.isSuccess);
 		const errorResponses = responseInfos.filter((response) => !response.isSuccess && response.type !== this.config.Ts.Keyword.Any);
 		const handleResponseHeaders = (src) => {
@@ -1907,6 +1951,7 @@ var SchemaRoutes = class {
 		return {
 			contentTypes,
 			responses: responseInfos,
+			links,
 			success: {
 				schema: successResponse,
 				type: successResponse?.type || this.config.Ts.Keyword.Any
@@ -2077,7 +2122,7 @@ var SchemaRoutes = class {
 		const { routeNameDuplicatesMap, templatesToRender } = this.config;
 		const routeNameTemplate = templatesToRender.routeName;
 		const routeNameFromTemplate = this.templatesWorker.renderTemplate(routeNameTemplate, { routeInfo: rawRouteInfo });
-		const routeName = this.config.hooks.onFormatRouteName(rawRouteInfo, routeNameFromTemplate) || routeNameFromTemplate;
+		const routeName = this.config.hooks.onFormatRouteName?.(rawRouteInfo, routeNameFromTemplate) || routeNameFromTemplate;
 		const duplicateIdentifier = `${moduleName}|${routeName}`;
 		if (routeNameDuplicatesMap.has(duplicateIdentifier)) {
 			routeNameDuplicatesMap.set(duplicateIdentifier, routeNameDuplicatesMap.get(duplicateIdentifier) + 1);
@@ -2089,10 +2134,10 @@ var SchemaRoutes = class {
 			original: routeName,
 			duplicate: duplicates > 1
 		};
-		return this.config.hooks.onCreateRouteName(routeNameInfo, rawRouteInfo) || routeNameInfo;
+		return this.config.hooks.onCreateRouteName?.(routeNameInfo, rawRouteInfo) || routeNameInfo;
 	};
-	parseRouteInfo = (rawRouteName, routeInfo, method, usageSchema, parsedSchemas) => {
-		const { security: globalSecurity } = usageSchema;
+	parseRouteInfo = (rawRouteName, routeInfo, method, resolvedSwaggerSchema, parsedSchemas) => {
+		const { security: globalSecurity } = resolvedSwaggerSchema.usageSchema;
 		const { moduleNameIndex, moduleNameFirstTag, extractRequestParams } = this.config;
 		const { operationId, requestBody, security, parameters, summary, description, tags, responses, requestBodyName, produces, consumes, ...otherInfo } = routeInfo;
 		const { route, pathParams: pathParamsFromRouteName, queryParams: queryParamsFromRouteName } = this.parseRouteName(rawRouteName);
@@ -2109,7 +2154,7 @@ var SchemaRoutes = class {
 			description: pathArgSchema.description
 		}));
 		const pathArgsNames = pathArgs.map((arg) => arg.name);
-		const responseBodyInfo = this.getResponseBodyInfo(routeInfo, parsedSchemas);
+		const responseBodyInfo = this.getResponseBodyInfo(routeInfo, parsedSchemas, resolvedSwaggerSchema);
 		const rawRouteInfo = {
 			...otherInfo,
 			pathArgs,
@@ -2118,6 +2163,7 @@ var SchemaRoutes = class {
 			route: rawRouteName,
 			moduleName,
 			responsesTypes: responseBodyInfo.responses,
+			links: responseBodyInfo.links,
 			description,
 			tags,
 			summary,
@@ -2213,13 +2259,13 @@ var SchemaRoutes = class {
 			raw: rawRouteInfo
 		};
 	};
-	attachSchema = ({ usageSchema, parsedSchemas }) => {
+	attachSchema = (resolvedSwaggerSchema, parsedSchemas) => {
 		this.config.routeNameDuplicatesMap.clear();
-		const pathsEntries = Object.entries(usageSchema.paths || {});
+		const pathsEntries = Object.entries(resolvedSwaggerSchema.usageSchema.paths || {});
 		for (const [rawRouteName, routeInfoByMethodsMap] of pathsEntries) {
-			const routeInfosMap = this.createRequestsMap(routeInfoByMethodsMap);
+			const routeInfosMap = this.createRequestsMap(resolvedSwaggerSchema, routeInfoByMethodsMap);
 			for (const [method, routeInfo] of Object.entries(routeInfosMap)) {
-				const parsedRouteInfo = this.parseRouteInfo(rawRouteName, routeInfo, method, usageSchema, parsedSchemas);
+				const parsedRouteInfo = this.parseRouteInfo(rawRouteName, routeInfo, method, resolvedSwaggerSchema, parsedSchemas);
 				const processedRouteInfo = this.config.hooks.onCreateRoute(parsedRouteInfo);
 				if (processedRouteInfo !== false) {
 					const route = processedRouteInfo || parsedRouteInfo;
@@ -2273,30 +2319,353 @@ var SchemaRoutes = class {
 };
 
 //#endregion
-//#region src/schema-walker.ts
-var SchemaWalker = class {
-	config;
-	swaggerSchemaResolver;
-	schemas = /* @__PURE__ */ new Map();
-	caches = /* @__PURE__ */ new Map();
-	constructor(config, swaggerSchemaResolver) {
+//#region src/resolved-swagger-schema.ts
+var ResolvedSwaggerSchema = class ResolvedSwaggerSchema {
+	parsedRefsCache = /* @__PURE__ */ new Map();
+	externalSchemaCache = /* @__PURE__ */ new Map();
+	httpMethodSegments = new Set([
+		"get",
+		"put",
+		"post",
+		"delete",
+		"patch",
+		"options",
+		"head",
+		"trace",
+		"parameters"
+	]);
+	normalizeRef(ref) {
+		let normalizedRef = ref;
+		normalizedRef = normalizedRef.replace(/\/#(?=\/)/, "#");
+		normalizedRef = normalizedRef.replace(/#(?!\/)/, "#/");
+		return normalizedRef;
+	}
+	createEscapedPathsRefVariant(ref) {
+		const [prefix = "", rawPointer = ""] = this.normalizeRef(ref).split("#");
+		const pointer = rawPointer.startsWith("/") ? rawPointer : `/${rawPointer}`;
+		if (!pointer.startsWith("/paths/") || pointer.startsWith("/paths/~1")) return null;
+		const rest = pointer.slice(7);
+		if (!rest) return null;
+		const parts = rest.split("/");
+		const last = parts.at(-1)?.toLowerCase() || "";
+		const hasTailSegment = this.httpMethodSegments.has(last);
+		const pathParts = hasTailSegment ? parts.slice(0, -1) : parts;
+		const tail = hasTailSegment ? `/${parts.at(-1)}` : "";
+		if (!pathParts.length) return null;
+		return `${prefix}#/paths/${`~1${pathParts.join("/").replace(/\//g, "~1")}`}${tail}`;
+	}
+	isHttpUrl(value) {
+		return /^https?:\/\//i.test(value);
+	}
+	getRemoteRequestHeaders() {
+		return Object.assign({}, this.config.authorizationToken ? { Authorization: this.config.authorizationToken } : {}, this.config.requestOptions?.headers || {});
+	}
+	stripHash(urlOrPath) {
+		return urlOrPath.split("#")[0] || urlOrPath;
+	}
+	extractRefsFromSchema(schema) {
+		const refs = /* @__PURE__ */ new Set();
+		const walk = (node) => {
+			if (!node || typeof node !== "object") return;
+			if (Array.isArray(node)) {
+				for (const item of node) walk(item);
+				return;
+			}
+			const recordNode = node;
+			if (typeof recordNode.$ref === "string") refs.add(recordNode.$ref);
+			for (const value of Object.values(recordNode)) walk(value);
+		};
+		walk(schema);
+		return [...refs];
+	}
+	async fetchRemoteSchemaDocument(url) {
+		try {
+			const response = await fetch(url, { headers: this.getRemoteRequestHeaders() });
+			if (!response.ok) return null;
+			const content = await response.text();
+			try {
+				const parsed = JSON.parse(content);
+				if (parsed && typeof parsed === "object") return parsed;
+			} catch {
+				const parsed = yaml.parse(content);
+				if (parsed && typeof parsed === "object") return parsed;
+			}
+		} catch (e) {
+			consola.default.debug(e);
+		}
+		return null;
+	}
+	async warmUpRemoteSchemasCache() {
+		if (typeof this.config.url !== "string" || !this.isHttpUrl(this.config.url)) return;
+		const visited = /* @__PURE__ */ new Set();
+		const queue = [this.stripHash(this.config.url)];
+		while (queue.length > 0) {
+			const currentUrl = queue.shift();
+			if (!currentUrl || visited.has(currentUrl)) continue;
+			visited.add(currentUrl);
+			if (this.externalSchemaCache.has(currentUrl)) continue;
+			const schema = await this.fetchRemoteSchemaDocument(currentUrl);
+			if (!schema) continue;
+			this.externalSchemaCache.set(currentUrl, schema);
+			for (const ref of this.extractRefsFromSchema(schema)) {
+				const normalizedRef = this.normalizeRef(ref);
+				if (normalizedRef.startsWith("#")) continue;
+				const [externalPath = ""] = normalizedRef.split("#");
+				if (!externalPath) continue;
+				let absoluteUrl = "";
+				try {
+					absoluteUrl = this.isHttpUrl(externalPath) ? this.stripHash(externalPath) : this.stripHash(new URL(externalPath, currentUrl).toString());
+				} catch (e) {
+					consola.default.debug(e);
+				}
+				if (absoluteUrl && !visited.has(absoluteUrl)) queue.push(absoluteUrl);
+			}
+		}
+	}
+	collectRemoteAbsoluteRefCandidates(ref) {
+		if (!ref || this.isHttpUrl(ref) || ref.startsWith("#")) return [];
+		const [relativePath = "", rawPointer = ""] = this.normalizeRef(ref).split("#");
+		if (!relativePath) return [];
+		const pointer = rawPointer ? rawPointer.startsWith("/") ? rawPointer : `/${rawPointer}` : "";
+		const bases = /* @__PURE__ */ new Set();
+		if (typeof this.config.url === "string" && this.isHttpUrl(this.config.url)) bases.add(this.config.url);
+		for (const cachedUrl of this.externalSchemaCache.keys()) if (this.isHttpUrl(cachedUrl)) bases.add(cachedUrl);
+		for (const resolver of this.resolvers) try {
+			const resolverPaths = typeof resolver.paths === "function" ? resolver.paths() : [];
+			for (const resolverPath of resolverPaths) if (typeof resolverPath === "string" && this.isHttpUrl(resolverPath)) bases.add(resolverPath);
+		} catch (e) {
+			consola.default.debug(e);
+		}
+		const results = /* @__PURE__ */ new Set();
+		for (const base of bases) try {
+			const absolutePath = new URL(relativePath, base).toString();
+			results.add(pointer ? `${absolutePath}#${pointer}` : absolutePath);
+		} catch (e) {
+			consola.default.debug(e);
+		}
+		return [...results];
+	}
+	resolveFromRemoteSchemaCache(absoluteRef) {
+		const [externalPath = "", rawPointer = ""] = this.normalizeRef(absoluteRef).split("#");
+		if (!externalPath || !this.isHttpUrl(externalPath)) return null;
+		const schema = this.externalSchemaCache.get(this.stripHash(externalPath));
+		if (!schema) return null;
+		const pointer = rawPointer ? rawPointer.startsWith("/") ? rawPointer : `/${rawPointer}` : "/";
+		const resolved = this.resolveJsonPointer(schema, pointer);
+		if (resolved == null) return null;
+		return this.absolutizeLocalRefs(resolved, this.stripHash(externalPath));
+	}
+	constructor(config, usageSchema, originalSchema, resolvers) {
 		this.config = config;
-		this.swaggerSchemaResolver = swaggerSchemaResolver;
+		this.usageSchema = usageSchema;
+		this.originalSchema = originalSchema;
+		this.resolvers = resolvers;
+		this.usageSchema = usageSchema;
+		this.originalSchema = originalSchema;
+	}
+	getRefDetails(ref) {
+		const normalizedRef = this.normalizeRef(ref);
+		if (!this.parsedRefsCache.has(ref)) {
+			const isLocal = normalizedRef.startsWith("#");
+			if (isLocal) this.parsedRefsCache.set(ref, {
+				ref: normalizedRef,
+				isLocal,
+				externalUrlOrPath: null
+			});
+			else {
+				const externalUrlOrPath = normalizedRef.split("#")[0] || "";
+				let externalOpenapiFileName = externalUrlOrPath.replace(/\/$/, "").split("/").at(-1) || "";
+				if (externalOpenapiFileName.endsWith(".json") || externalOpenapiFileName.endsWith(".yaml")) externalOpenapiFileName = externalOpenapiFileName.slice(0, -5);
+				else if (externalOpenapiFileName.endsWith(".yml")) externalOpenapiFileName = externalOpenapiFileName.slice(0, -4);
+				this.parsedRefsCache.set(ref, {
+					ref: normalizedRef,
+					isLocal,
+					externalUrlOrPath,
+					externalOpenapiFileName
+				});
+			}
+		}
+		const cachedRef = this.parsedRefsCache.get(ref);
+		if (cachedRef) return cachedRef;
+		if (normalizedRef.startsWith("#")) return {
+			ref: normalizedRef,
+			isLocal: true,
+			externalUrlOrPath: null
+		};
+		return {
+			ref: normalizedRef,
+			isLocal: false,
+			externalUrlOrPath: normalizedRef.split("#")[0] || null,
+			externalOpenapiFileName: ""
+		};
+	}
+	isLocalRef(ref) {
+		return this.getRefDetails(ref).isLocal;
+	}
+	getRef(ref) {
+		if (!ref) return null;
+		const normalizedRef = this.normalizeRef(ref);
+		const escapedPathsRefVariant = this.createEscapedPathsRefVariant(ref);
+		if (normalizedRef !== ref) {
+			const resolvedByNormalizedRef = this.tryToResolveRef(normalizedRef);
+			if (resolvedByNormalizedRef) return this.normalizeResolvedExternalSchemaRef(normalizedRef, resolvedByNormalizedRef);
+		}
+		if (escapedPathsRefVariant) {
+			const resolvedByEscapedPathsRef = this.tryToResolveRef(escapedPathsRefVariant);
+			if (resolvedByEscapedPathsRef) return this.normalizeResolvedExternalSchemaRef(escapedPathsRefVariant, resolvedByEscapedPathsRef);
+		}
+		const remoteAbsoluteCandidates = this.collectRemoteAbsoluteRefCandidates(ref);
+		for (const remoteAbsoluteRef of remoteAbsoluteCandidates) {
+			const resolvedFromRemoteCache = this.resolveFromRemoteSchemaCache(remoteAbsoluteRef);
+			if (resolvedFromRemoteCache) return resolvedFromRemoteCache;
+			const resolvedByRemoteAbsoluteRef = this.tryToResolveRef(remoteAbsoluteRef);
+			if (resolvedByRemoteAbsoluteRef) return this.normalizeResolvedExternalSchemaRef(remoteAbsoluteRef, resolvedByRemoteAbsoluteRef);
+		}
+		const resolvedByOrigRef = this.tryToResolveRef(ref);
+		if (resolvedByOrigRef) return this.normalizeResolvedExternalSchemaRef(ref, resolvedByOrigRef);
+		if (/#[a-z]/.test(ref)) {
+			const fixedRef = ref.replace(/#[a-z]/, (match) => {
+				const [hashtag, char] = match.split("");
+				return `${hashtag}/${char}`;
+			});
+			const resolvedByFixedRef = this.tryToResolveRef(fixedRef);
+			if (resolvedByFixedRef) return this.normalizeResolvedExternalSchemaRef(fixedRef, resolvedByFixedRef);
+		}
+		return this.tryToResolveRefFromFile(normalizedRef);
+	}
+	tryToResolveRef(ref) {
+		if (!this.resolvers || !ref) return null;
+		for (const resolver of this.resolvers) try {
+			return resolver.get(ref);
+		} catch (e) {
+			consola.default.debug(e);
+		}
+		return null;
+	}
+	readExternalSchema(filePath) {
+		if (this.externalSchemaCache.has(filePath)) return this.externalSchemaCache.get(filePath) || null;
+		if (!node_fs.existsSync(filePath)) return null;
+		try {
+			const content = node_fs.readFileSync(filePath, "utf8");
+			const parsed = JSON.parse(content);
+			this.externalSchemaCache.set(filePath, parsed);
+			return parsed;
+		} catch {
+			try {
+				const content = node_fs.readFileSync(filePath, "utf8");
+				const parsed = yaml.parse(content);
+				if (parsed && typeof parsed === "object") {
+					this.externalSchemaCache.set(filePath, parsed);
+					return parsed;
+				}
+			} catch (e) {
+				consola.default.debug(e);
+			}
+		}
+		return null;
+	}
+	resolveJsonPointer(source, pointer) {
+		if (!source || typeof source !== "object") return null;
+		if (!pointer || pointer === "/") return source;
+		const tokens = pointer.replace(/^\/+/, "").split("/").filter(Boolean).map((part) => decodeURIComponent(part.replace(/~1/g, "/").replace(/~0/g, "~")));
+		let current = source;
+		for (const token of tokens) {
+			if (!current || typeof current !== "object") return null;
+			current = current[token];
+		}
+		return current ?? null;
+	}
+	absolutizeLocalRefs(value, externalPath) {
+		if (value == null || typeof value !== "object") return value;
+		const cloneValue = structuredClone(value);
+		const walk = (node) => {
+			if (!node || typeof node !== "object") return;
+			if (Array.isArray(node)) {
+				for (const item of node) walk(item);
+				return;
+			}
+			const recordNode = node;
+			if (typeof recordNode.$ref === "string" && recordNode.$ref.startsWith("#")) recordNode.$ref = `${externalPath}${this.normalizeRef(recordNode.$ref)}`;
+			for (const nested of Object.values(recordNode)) walk(nested);
+		};
+		walk(cloneValue);
+		return cloneValue;
+	}
+	normalizeResolvedExternalSchemaRef(ref, resolved) {
+		const normalizedRef = this.normalizeRef(ref);
+		if (normalizedRef.startsWith("#")) return resolved;
+		const externalPath = normalizedRef.split("#")[0] || "";
+		if (!externalPath) return resolved;
+		return this.absolutizeLocalRefs(resolved, externalPath);
+	}
+	collectExternalRefCandidates(externalPath) {
+		const candidates = /* @__PURE__ */ new Set();
+		if (/^https?:\/\//i.test(externalPath)) return [];
+		if (node_path.default.isAbsolute(externalPath)) candidates.add(externalPath);
+		const inputPath = this.config.input;
+		if (typeof inputPath === "string" && inputPath) candidates.add(node_path.default.resolve(node_path.default.dirname(inputPath), externalPath));
+		for (const resolver of this.resolvers) try {
+			const resolverPaths = typeof resolver.paths === "function" ? resolver.paths() : [];
+			for (const resolverPath of resolverPaths) {
+				if (typeof resolverPath !== "string") continue;
+				if (/^https?:\/\//i.test(resolverPath)) continue;
+				candidates.add(node_path.default.resolve(node_path.default.dirname(resolverPath), externalPath));
+			}
+		} catch (e) {
+			consola.default.debug(e);
+		}
+		return [...candidates];
+	}
+	tryToResolveRefFromFile(ref) {
+		if (!ref || ref.startsWith("#")) return null;
+		const [externalPath = "", rawPointer = ""] = ref.split("#");
+		if (!externalPath) return null;
+		const pointer = rawPointer ? rawPointer.startsWith("/") ? rawPointer : `/${rawPointer}` : "/";
+		const candidates = this.collectExternalRefCandidates(externalPath);
+		for (const candidate of candidates) {
+			const schema = this.readExternalSchema(candidate);
+			const resolved = this.resolveJsonPointer(schema, pointer);
+			if (resolved != null) return this.absolutizeLocalRefs(resolved, externalPath);
+		}
+		return null;
+	}
+	static async create(config, usageSchema, originalSchema) {
+		const resolvers = [];
+		const options = {
+			continueOnError: true,
+			mutateInputSchema: true,
+			dereference: {},
+			validate: {
+				schema: false,
+				spec: false
+			},
+			resolve: {
+				external: true,
+				http: {
+					...config.requestOptions,
+					headers: Object.assign({}, config.authorizationToken ? { Authorization: config.authorizationToken } : {}, config.requestOptions?.headers ?? {})
+				}
+			}
+		};
+		try {
+			resolvers.push(await _apidevtools_swagger_parser.default.resolve(originalSchema, options));
+		} catch (e) {
+			consola.default.debug(e);
+		}
+		try {
+			resolvers.push(await _apidevtools_swagger_parser.default.resolve(usageSchema, options));
+		} catch (e) {
+			consola.default.debug(e);
+		}
+		try {
+			resolvers.push(await _apidevtools_swagger_parser.default.resolve(config.url || config.input || config.spec, options));
+		} catch (e) {
+			consola.default.debug(e);
+		}
+		const resolvedSwaggerSchema = new ResolvedSwaggerSchema(config, usageSchema, originalSchema, resolvers);
+		await resolvedSwaggerSchema.warmUpRemoteSchemasCache();
+		return resolvedSwaggerSchema;
 	}
-	addSchema = (name, schema) => {
-		this.schemas.set(name, structuredClone(schema));
-	};
-	_isLocalRef = (ref) => {
-		return ref.startsWith("#");
-	};
-	_isRemoteRef = (ref) => {
-		return ref.startsWith("http://") || ref.startsWith("https://");
-	};
-	_getRefDataFromSchema = (schema, ref) => {
-		const refData = (0, es_toolkit_compat.get)(schema, ref.replace("#", "").split("/"));
-		if (refData) this.caches.set(ref, refData);
-		return refData;
-	};
 };
 
 //#endregion
@@ -2333,10 +2702,15 @@ var SwaggerSchemaResolver = class {
 	}
 	async create() {
 		const { spec, patch, input, url, authorizationToken } = this.config;
-		if (spec) return await this.convertSwaggerObject(spec, { patch });
-		const swaggerSchemaFile = await this.fetchSwaggerSchemaFile(input, url, authorizationToken);
-		const swaggerSchemaObject = this.processSwaggerSchemaFile(swaggerSchemaFile);
-		return await this.convertSwaggerObject(swaggerSchemaObject, { patch });
+		let swaggerSchemas;
+		if (spec) swaggerSchemas = await this.convertSwaggerObject(spec, { patch });
+		else {
+			const swaggerSchemaFile = await this.fetchSwaggerSchemaFile(input, url, authorizationToken);
+			const swaggerSchemaObject = this.processSwaggerSchemaFile(swaggerSchemaFile);
+			swaggerSchemas = await this.convertSwaggerObject(swaggerSchemaObject, { patch });
+		}
+		this.fixSwaggerSchemas(swaggerSchemas);
+		return ResolvedSwaggerSchema.create(this.config, swaggerSchemas.usageSchema, swaggerSchemas.originalSchema);
 	}
 	convertSwaggerObject(swaggerSchema, converterOptions) {
 		return new Promise((resolve) => {
@@ -2388,7 +2762,26 @@ var SwaggerSchemaResolver = class {
 			return yaml.parse(file);
 		}
 	}
-	fixSwaggerSchema({ usageSchema, originalSchema }) {
+	normalizeRefValue(ref) {
+		const refWithoutSlashBeforeHash = ref.split("/#/").join("#/");
+		const hashIndex = refWithoutSlashBeforeHash.indexOf("#");
+		if (hashIndex === -1) return refWithoutSlashBeforeHash;
+		if (refWithoutSlashBeforeHash[hashIndex + 1] === "/") return refWithoutSlashBeforeHash;
+		return `${refWithoutSlashBeforeHash.slice(0, hashIndex + 1)}/${refWithoutSlashBeforeHash.slice(hashIndex + 1)}`;
+	}
+	normalizeRefsInSchema(schema) {
+		if (!schema || typeof schema !== "object") return;
+		if (Array.isArray(schema)) {
+			for (const value of schema) this.normalizeRefsInSchema(value);
+			return;
+		}
+		const objectSchema = schema;
+		if (typeof objectSchema.$ref === "string") objectSchema.$ref = this.normalizeRefValue(objectSchema.$ref);
+		for (const value of Object.values(objectSchema)) this.normalizeRefsInSchema(value);
+	}
+	fixSwaggerSchemas({ usageSchema, originalSchema }) {
+		this.normalizeRefsInSchema(usageSchema);
+		this.normalizeRefsInSchema(originalSchema);
 		const usagePaths = (0, es_toolkit_compat.get)(usageSchema, "paths") || {};
 		const originalPaths = (0, es_toolkit_compat.get)(originalSchema, "paths") || {};
 		for (const [route, usagePathObject] of Object.entries(usagePaths)) {
@@ -2397,9 +2790,10 @@ var SwaggerSchemaResolver = class {
 				const originalRouteInfo = (0, es_toolkit_compat.get)(originalPathObject, methodName) || {};
 				const usageRouteParams = (0, es_toolkit_compat.get)(usageRouteInfo, "parameters") || [];
 				const originalRouteParams = (0, es_toolkit_compat.get)(originalRouteInfo, "parameters") || [];
+				const usageAsOpenapiv2 = usageRouteInfo;
 				if (typeof usageRouteInfo === "object") {
-					usageRouteInfo.consumes = (0, es_toolkit.uniq)((0, es_toolkit.compact)([...usageRouteInfo.consumes || [], ...originalRouteInfo.consumes || []]));
-					usageRouteInfo.produces = (0, es_toolkit.uniq)((0, es_toolkit.compact)([...usageRouteInfo.produces || [], ...originalRouteInfo.produces || []]));
+					usageAsOpenapiv2.consumes = (0, es_toolkit.uniq)((0, es_toolkit.compact)([...usageAsOpenapiv2.consumes || [], ...originalRouteInfo.consumes || []]));
+					usageAsOpenapiv2.produces = (0, es_toolkit.uniq)((0, es_toolkit.compact)([...usageAsOpenapiv2.produces || [], ...originalRouteInfo.produces || []]));
 				}
 				for (const originalRouteParam of originalRouteParams) if (!usageRouteParams.find((param) => originalRouteParam.in === param.in && originalRouteParam.name === param.name)) usageRouteParams.push(originalRouteParam);
 			}
@@ -2574,7 +2968,7 @@ var TypeNameFormatter = class {
 		]).join("_");
 		if (this.formattedModelNamesMap.has(hashKey)) return this.formattedModelNamesMap.get(hashKey);
 		const formattedName = (0, es_toolkit_compat.startCase)(`${typePrefix}_${this.fixModelName(name, { type: schemaType })}_${typeSuffix}`).replace(/\s/g, "");
-		const formattedResultName = this.config.hooks.onFormatTypeName(formattedName, name, schemaType) || formattedName;
+		const formattedResultName = this.config.hooks.onFormatTypeName?.(formattedName, name, schemaType) || formattedName;
 		this.formattedModelNamesMap.set(hashKey, formattedResultName);
 		return formattedResultName;
 	};
@@ -2673,38 +3067,35 @@ var CodeGenProcess = class {
 	fileSystem;
 	codeFormatter;
 	templatesWorker;
-	schemaWalker;
 	javascriptTranslator;
+	swaggerRefs;
 	constructor(config) {
 		this.config = new CodeGenConfig(config);
 		this.fileSystem = new FileSystem();
 		this.swaggerSchemaResolver = new SwaggerSchemaResolver(this.config, this.fileSystem);
-		this.schemaWalker = new SchemaWalker(this.config, this.swaggerSchemaResolver);
 		this.schemaComponentsMap = new SchemaComponentsMap(this.config);
 		this.typeNameFormatter = new TypeNameFormatter(this.config);
 		this.templatesWorker = new TemplatesWorker(this.config, this.fileSystem, this.getRenderTemplateData);
 		this.codeFormatter = new CodeFormatter(this.config);
-		this.schemaParserFabric = new SchemaParserFabric(this.config, this.templatesWorker, this.schemaComponentsMap, this.typeNameFormatter, this.schemaWalker);
+		this.schemaParserFabric = new SchemaParserFabric(this.config, this.templatesWorker, this.schemaComponentsMap, this.typeNameFormatter);
 		this.schemaRoutes = new SchemaRoutes(this.config, this.schemaParserFabric, this.schemaComponentsMap, this.templatesWorker, this.typeNameFormatter);
 		this.javascriptTranslator = new JavascriptTranslator(this.config, this.codeFormatter);
 	}
 	async start() {
 		this.config.update({ templatePaths: this.templatesWorker.getTemplatePaths(this.config) });
 		this.config.update({ templatesToRender: this.templatesWorker.getTemplates(this.config) });
-		const swagger = await this.swaggerSchemaResolver.create();
-		this.swaggerSchemaResolver.fixSwaggerSchema(swagger);
+		const resolvedSwaggerSchema = await this.swaggerSchemaResolver.create();
 		this.config.update({
-			swaggerSchema: swagger.usageSchema,
-			originalSchema: swagger.originalSchema
+			resolvedSwaggerSchema,
+			swaggerSchema: resolvedSwaggerSchema.usageSchema,
+			originalSchema: resolvedSwaggerSchema.originalSchema
 		});
-		this.schemaWalker.addSchema("$usage", swagger.usageSchema);
-		this.schemaWalker.addSchema("$original", swagger.originalSchema);
 		consola.consola.info("start generating your typescript api");
-		this.config.update(this.config.hooks.onInit(this.config, this) || this.config);
-		if (this.config.swaggerSchema) swagger.usageSchema = this.config.swaggerSchema;
-		if (this.config.originalSchema) swagger.originalSchema = this.config.originalSchema;
+		this.config.update(this.config.hooks.onInit?.(this.config, this) || this.config);
+		if (this.config.swaggerSchema) resolvedSwaggerSchema.usageSchema = this.config.swaggerSchema;
+		if (this.config.originalSchema) resolvedSwaggerSchema.originalSchema = this.config.originalSchema;
 		this.schemaComponentsMap.clear();
-		for (const [componentName, component] of Object.entries(swagger.usageSchema.components || {})) for (const [typeName, rawTypeData] of Object.entries(component)) this.schemaComponentsMap.createComponent(this.schemaComponentsMap.createRef([
+		for (const [componentName, component] of Object.entries(resolvedSwaggerSchema.usageSchema.components || {})) for (const [typeName, rawTypeData] of Object.entries(component)) this.schemaComponentsMap.createComponent(this.schemaComponentsMap.createRef([
 			"components",
 			componentName,
 			typeName
@@ -2716,12 +3107,9 @@ var CodeGenProcess = class {
 			schemaComponent.typeData = parsed;
 			return parsed;
 		});
-		this.schemaRoutes.attachSchema({
-			usageSchema: swagger.usageSchema,
-			parsedSchemas
-		});
+		this.schemaRoutes.attachSchema(resolvedSwaggerSchema, parsedSchemas);
 		const rawConfiguration = {
-			apiConfig: this.createApiConfig(swagger.usageSchema),
+			apiConfig: this.createApiConfig(resolvedSwaggerSchema.usageSchema),
 			config: this.config,
 			modelTypes: this.collectModelTypes(),
 			hasSecurityRoutes: this.schemaRoutes.hasSecurityRoutes,
@@ -2735,7 +3123,7 @@ var CodeGenProcess = class {
 			customTranslator: this.config.customTranslator ? new this.config.customTranslator() : null,
 			utils: this.getRenderTemplateData().utils
 		};
-		const configuration = this.config.hooks.onPrepareConfig(rawConfiguration) || rawConfiguration;
+		const configuration = this.config.hooks.onPrepareConfig?.(rawConfiguration) || rawConfiguration;
 		if (this.fileSystem.pathIsExist(this.config.output)) {
 			if (this.config.cleanOutput) {
 				consola.consola.debug("cleaning dir", this.config.output);
@@ -3174,4 +3562,4 @@ Object.defineProperty(exports, 'version', {
     return version;
   }
 });
-//# sourceMappingURL=generate-templates-C4JBmSNw.cjs.map
+//# sourceMappingURL=generate-templates-BlSkwa8l.cjs.map