swagger-typescript-api 13.12.1 → 13.12.3

package/dist/{src-BI71PJBk.mjs → src-Dzta9jYV.mjs}

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "./chunk-D7D4PA-g.mjs";
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import * as module from "node:module";
 import consola, { consola as consola$1 } from "consola";
 import * as esToolkit from "es-toolkit";
@@ -17,6 +17,8 @@ import * as swagger2openapi from "swagger2openapi";
 import * as fs from "node:fs";
 import SwaggerParser from "@apidevtools/swagger-parser";
 import * as YAML from "yaml";
+import * as dns from "node:dns/promises";
+import * as net from "node:net";
 import * as url$1 from "node:url";
 import url from "node:url";
 import { Eta } from "eta";
@@ -169,7 +171,7 @@ var ComponentTypeNameResolver = class extends NameResolver {
 //#endregion
 //#region package.json
 var name = "swagger-typescript-api";
-var version = "13.12.1";
+var version = "13.12.3";
 var description = "Generate the API client for Fetch or Axios from an OpenAPI Specification";
 //#endregion
 //#region src/constants.ts
@@ -237,6 +239,12 @@ const SCHEMA_TYPES$1 = {
 	COMPLEX_UNKNOWN: "__unknown"
 };
 //#endregion
+//#region src/util/escape-js-string-literal.ts
+/** Escapes a value for insertion into a double-quoted JS/TS string literal (without surrounding quotes). */
+function escapeJsStringLiteral(value) {
+	return JSON.stringify(value).slice(1, -1);
+}
+//#endregion
 //#region src/util/object-assign.ts
 const objectAssign = (target, updater) => {
 	if (!updater) return;
@@ -462,7 +470,7 @@ var CodeGenConfig = class {
 		/**
 		* "$A"
 		*/
-		StringValue: (content) => `"${content}"`,
+		StringValue: (content) => `"${escapeJsStringLiteral(String(content))}"`,
 		/**
 		* $A
 		*/
@@ -1842,6 +1850,15 @@ var SchemaParserFabric = class {
 	};
 };
 //#endregion
+//#region src/util/escape-js-template-literal-with-path-params.ts
+/**
+* Escapes `\`, backticks, and `${` for insertion into a JS template literal
+* (without surrounding backticks).
+*/
+function escapeJsTemplateLiteralStatic(value) {
+	return value.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+}
+//#endregion
 //#region src/util/id.ts
 const generateId = () => crypto.randomUUID();
 //#endregion
@@ -1964,10 +1981,11 @@ var SchemaRoutes = class {
 				in: "path"
 			});
 		}
+		const escapedRouteName = escapeJsTemplateLiteralStatic(routeName || "");
 		let fixedRoute = pathParams.reduce((fixedRoute, pathParam, i, arr) => {
 			const insertion = this.config.hooks.onInsertPathParam(pathParam.name, i, arr, fixedRoute) || pathParam.name;
 			return fixedRoute.replace(pathParam.$match, `\${${insertion}}`);
-		}, routeName || "");
+		}, escapedRouteName);
 		const queryParamMatches = fixedRoute.match(/(\{\?.*\})/g);
 		const queryParams = [];
 		if (queryParamMatches?.length) {
@@ -2673,6 +2691,118 @@ function parseSchemaContent(content) {
 	}
 }
 //#endregion
+//#region src/util/remote-schema-fetch.ts
+const MAX_REDIRECTS = 5;
+function isPrivateIpv4(ip) {
+	const match = ip.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+	if (!match) return false;
+	const octets = match.slice(1).map(Number);
+	if (octets.some((octet) => octet > 255)) return false;
+	const [a, b] = octets;
+	return a === 0 || a === 10 || a === 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168;
+}
+function isPrivateIpv6(ip) {
+	const normalized = ip.toLowerCase();
+	if (normalized === "::" || normalized === "::1") return true;
+	if (normalized.startsWith("fe80:")) return true;
+	const firstHextet = normalized.split(":")[0] ?? "";
+	if (firstHextet >= "fc00" && firstHextet <= "fdff") return true;
+	const ipv4Mapped = normalized.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+	if (ipv4Mapped?.[1]) return isPrivateIpv4(ipv4Mapped[1]);
+	const ipv4MappedHex = normalized.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
+	if (ipv4MappedHex?.[1] && ipv4MappedHex?.[2]) {
+		const h1 = parseInt(ipv4MappedHex[1], 16);
+		const h2 = parseInt(ipv4MappedHex[2], 16);
+		return isPrivateIpv4(`${h1 >> 8 & 255}.${h1 & 255}.${h2 >> 8 & 255}.${h2 & 255}`);
+	}
+	return false;
+}
+function isPrivateIp(ip) {
+	const family = net.isIP(ip);
+	if (family === 4) return isPrivateIpv4(ip);
+	if (family === 6) return isPrivateIpv6(ip);
+	return false;
+}
+function isBlockedHostname(hostname) {
+	const normalized = hostname.toLowerCase();
+	return normalized === "localhost" || normalized.endsWith(".localhost");
+}
+async function resolveHostnameAddresses(hostname) {
+	try {
+		return (await dns.lookup(hostname, {
+			all: true,
+			verbatim: true
+		})).map((record) => record.address);
+	} catch {
+		return [];
+	}
+}
+async function isPublicRemoteHost(urlString) {
+	let parsed;
+	try {
+		parsed = new URL(urlString);
+	} catch {
+		return false;
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
+	const hostname = parsed.hostname.startsWith("[") && parsed.hostname.endsWith("]") ? parsed.hostname.slice(1, -1) : parsed.hostname;
+	if (isBlockedHostname(hostname)) return false;
+	if (net.isIP(hostname)) return !isPrivateIp(hostname);
+	const addresses = await resolveHostnameAddresses(hostname);
+	if (addresses.length === 0) return false;
+	return addresses.every((address) => !isPrivateIp(address));
+}
+function isSameHttpOrigin(a, b) {
+	if (typeof b !== "string") return false;
+	try {
+		const urlA = new URL(a);
+		const urlB = new URL(b);
+		return urlA.protocol === urlB.protocol && urlA.host === urlB.host;
+	} catch {
+		return false;
+	}
+}
+async function isRemoteSchemaFetchAllowed(urlString, policy) {
+	const { specSourceUrl, allowExplicitSpecUrl = false } = policy;
+	if (allowExplicitSpecUrl && typeof specSourceUrl === "string" && stripUrlHash(urlString) === stripUrlHash(specSourceUrl)) return true;
+	if (typeof specSourceUrl === "string" && isSameHttpOrigin(urlString, specSourceUrl)) return true;
+	return isPublicRemoteHost(urlString);
+}
+function stripUrlHash(urlString) {
+	return urlString.split("#")[0] || urlString;
+}
+function resolveRedirectUrl(location, baseUrl) {
+	try {
+		return new URL(location, baseUrl).toString();
+	} catch {
+		return null;
+	}
+}
+async function fetchRemoteSchemaResponse(urlString, init, policy) {
+	let currentUrl = urlString;
+	let redirectCount = 0;
+	while (true) {
+		if (!await isRemoteSchemaFetchAllowed(currentUrl, {
+			specSourceUrl: policy.specSourceUrl,
+			allowExplicitSpecUrl: policy.allowExplicitSpecUrl && redirectCount === 0
+		})) return null;
+		const response = await fetch(currentUrl, {
+			...init,
+			redirect: "manual"
+		});
+		if (response.status >= 300 && response.status < 400) {
+			const location = response.headers.get("location");
+			if (!location || redirectCount >= MAX_REDIRECTS) return null;
+			const redirectUrl = resolveRedirectUrl(location, currentUrl);
+			if (!redirectUrl) return null;
+			currentUrl = redirectUrl;
+			redirectCount += 1;
+			continue;
+		}
+		return response;
+	}
+}
+//#endregion
 //#region src/resolved-swagger-schema.ts
 var ResolvedSwaggerSchema = class ResolvedSwaggerSchema {
 	config;
@@ -2715,8 +2845,13 @@ var ResolvedSwaggerSchema = class ResolvedSwaggerSchema {
 	isHttpUrl(value) {
 		return /^https?:\/\//i.test(value);
 	}
-	getRemoteRequestHeaders() {
-		return Object.assign({}, this.config.authorizationToken ? { Authorization: this.config.authorizationToken } : {}, this.config.requestOptions?.headers || {});
+	isExplicitSpecUrl(url) {
+		return typeof this.config.url === "string" && this.stripHash(url) === this.stripHash(this.config.url);
+	}
+	getRemoteRequestHeaders(targetUrl) {
+		const headers = {};
+		if (this.config.authorizationToken && targetUrl && typeof this.config.url === "string" && isSameHttpOrigin(targetUrl, this.config.url)) headers.Authorization = this.config.authorizationToken;
+		return Object.assign(headers, this.config.requestOptions?.headers || {});
 	}
 	stripHash(urlOrPath) {
 		return urlOrPath.split("#")[0] || urlOrPath;
@@ -2861,8 +2996,11 @@ var ResolvedSwaggerSchema = class ResolvedSwaggerSchema {
 	}
 	async fetchRemoteSchemaDocument(url) {
 		try {
-			const response = await fetch(url, { headers: this.getRemoteRequestHeaders() });
-			if (!response.ok) return null;
+			const response = await fetchRemoteSchemaResponse(url, { headers: this.getRemoteRequestHeaders(url) }, {
+				specSourceUrl: typeof this.config.url === "string" ? this.config.url : void 0,
+				allowExplicitSpecUrl: this.isExplicitSpecUrl(url)
+			});
+			if (!response?.ok) return null;
 			const content = await response.text();
 			try {
 				const parsed = parseSchemaContent(content);
@@ -2893,7 +3031,7 @@ var ResolvedSwaggerSchema = class ResolvedSwaggerSchema {
 				const [externalPath = ""] = normalizedRef.split("#");
 				if (!externalPath) continue;
 				const absoluteUrl = this.resolveAbsoluteUrl(externalPath, currentUrl);
-				if (absoluteUrl && !visited.has(absoluteUrl)) queue.push(absoluteUrl);
+				if (absoluteUrl && !visited.has(absoluteUrl) && await isRemoteSchemaFetchAllowed(absoluteUrl, { specSourceUrl: this.config.url })) queue.push(absoluteUrl);
 			}
 		}
 	}
@@ -3113,7 +3251,7 @@ var ResolvedSwaggerSchema = class ResolvedSwaggerSchema {
 				external: true,
 				http: {
 					...config.requestOptions,
-					headers: Object.assign({}, config.authorizationToken ? { Authorization: config.authorizationToken } : {}, config.requestOptions?.headers ?? {})
+					headers: config.requestOptions?.headers ?? {}
 				}
 			}
 		};
@@ -3902,7 +4040,7 @@ var CodeGenProcess = class {
 				description: ""
 			}, externalDocs || {}),
 			tags: compact(tags || []),
-			baseUrl: serverUrl,
+			baseUrl: escapeJsStringLiteral(serverUrl ?? ""),
 			title,
 			version
 		};
@@ -4073,4 +4211,4 @@ async function generateApi(config) {
 //#endregion
 export { SCHEMA_TYPES as a, constants_exports as c, version as d, RequestContentKind as i, description as l, generateTemplates as n, CodeGenConfig as o, TemplatesGenConfig as r, HTTP_CLIENT as s, generateApi as t, name as u };
 
-//# sourceMappingURL=src-BI71PJBk.mjs.map
+//# sourceMappingURL=src-Dzta9jYV.mjs.map