@nestbridge/webpack 2.0.3 → 2.1.0

package/build/nestbridge.webpack.js

@@ -0,0 +1,1462 @@
+import { SyntaxKind, isArrayLiteralExpression, isArrayTypeNode, isArrowFunction, isBlock, isCallExpression, isClassDeclaration, isDecorator, isExportDeclaration, isExpressionStatement, isFalseLiteral, isFunctionExpression, isIdentifier, isImportDeclaration, isMethodDeclaration, isNamedExports, isNamedImports, isNewExpression, isNullLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isPropertyDeclaration, isReturnStatement, isSpreadElement, isStringLiteral, isStringLiteralLikeNode, isTrueLiteral, isTypeReferenceNode, isUnionTypeNode, isVariableStatement } from "typescript/unstable/ast";
+import { API } from "typescript/unstable/sync";
+import { existsSync, globSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, extname, join, posix, relative, resolve, sep } from "node:path";
+import { createUnplugin } from "unplugin";
+//#region ../unplugin/build/nestbridge.unplugin.js
+var getDecorators = (node) => {
+	const decorators = node.modifiers?.filter(isDecorator);
+	return decorators === void 0 || decorators.length === 0 ? void 0 : decorators;
+};
+var findDecorator = (node, decoratorName) => {
+	const decorators = getDecorators(node);
+	if (decorators === void 0) return;
+	return decorators.find((decorator) => decoratorNameOf(decorator) === decoratorName);
+};
+var findAnyDecorator = (node, decoratorNames) => {
+	const decorators = getDecorators(node);
+	if (decorators === void 0) return;
+	return decorators.find((decorator) => decoratorNames.includes(decoratorNameOf(decorator) ?? ""));
+};
+var decoratorNameOf = (decorator) => {
+	const expression = decorator.expression;
+	if (isCallExpression(expression) && isIdentifier(expression.expression)) return expression.expression.text;
+	if (isIdentifier(expression)) return expression.text;
+};
+var readStaticStringArgument = (decorator) => {
+	const expression = decorator.expression;
+	if (!isCallExpression(expression)) return {
+		ok: true,
+		value: void 0
+	};
+	const [firstArgument] = expression.arguments;
+	if (firstArgument === void 0) return {
+		ok: true,
+		value: void 0
+	};
+	if (isStringLiteralLikeNode(firstArgument)) return {
+		ok: true,
+		value: firstArgument.text
+	};
+	return {
+		ok: false,
+		argumentText: firstArgument.getText()
+	};
+};
+var HTTP_METHOD_DECORATOR_NAMES = {
+	Get: "GET",
+	Post: "POST",
+	Put: "PUT",
+	Patch: "PATCH",
+	Delete: "DELETE"
+};
+var locationOf = (sourceFile, node) => {
+	const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+	return {
+		line: line + 1,
+		column: character + 1
+	};
+};
+var SUPPORTED_PARAMETER_DECORATORS = [
+	"Param",
+	"Query",
+	"Body",
+	"Headers"
+];
+var KNOWN_UNSUPPORTED_PARAMETER_DECORATORS = [
+	"Req",
+	"Res",
+	"Request",
+	"Response"
+];
+var extractParameterDefinition = (parameter, index, context) => {
+	const decorator = findAnyDecorator(parameter, [...SUPPORTED_PARAMETER_DECORATORS, ...KNOWN_UNSUPPORTED_PARAMETER_DECORATORS]);
+	const location = locationOf(context.sourceFile, parameter);
+	if (decorator === void 0) {
+		context.diagnostics.push({
+			code: "unsupported-parameter",
+			title: "Unsupported parameter.",
+			controllerName: context.controllerName,
+			memberName: context.methodName,
+			detail: `Parameter "${parameter.name.getText()}" must be decorated with one of @Param, @Query, @Body, or @Headers to be transported through a NestBridge HTTP client.`,
+			filePath: context.filePath,
+			line: location.line,
+			column: location.column
+		});
+		return;
+	}
+	const decoratorName = decoratorNameOf(decorator);
+	if (decoratorName !== void 0 && KNOWN_UNSUPPORTED_PARAMETER_DECORATORS.includes(decoratorName)) {
+		context.diagnostics.push({
+			code: "unsupported-parameter",
+			title: "Unsupported parameter.",
+			controllerName: context.controllerName,
+			memberName: context.methodName,
+			detail: `@${decoratorName}() cannot be transported through a NestBridge HTTP client.`,
+			filePath: context.filePath,
+			line: location.line,
+			column: location.column
+		});
+		return;
+	}
+	if (!isIdentifier(parameter.name)) {
+		context.diagnostics.push({
+			code: "unsupported-parameter",
+			title: "Unsupported parameter.",
+			controllerName: context.controllerName,
+			memberName: context.methodName,
+			detail: "Destructured parameters cannot be transported through a NestBridge HTTP client.",
+			filePath: context.filePath,
+			line: location.line,
+			column: location.column
+		});
+		return;
+	}
+	const argument = readStaticStringArgument(decorator);
+	if (!argument.ok) {
+		context.diagnostics.push({
+			code: "unsupported-parameter",
+			title: "Unsupported parameter.",
+			controllerName: context.controllerName,
+			memberName: context.methodName,
+			detail: `@${decoratorName}() arguments must be statically analyzable string literals.`,
+			found: `@${decoratorName}(${argument.argumentText})`,
+			filePath: context.filePath,
+			line: location.line,
+			column: location.column
+		});
+		return;
+	}
+	const base = {
+		index,
+		parameterName: parameter.name.text
+	};
+	if (decoratorName === "Param") {
+		if (argument.value === void 0) {
+			context.diagnostics.push({
+				code: "unsupported-parameter",
+				title: "Unsupported parameter.",
+				controllerName: context.controllerName,
+				memberName: context.methodName,
+				detail: "A whole @Param() is not supported; provide a route parameter name such as @Param('id').",
+				filePath: context.filePath,
+				line: location.line,
+				column: location.column
+			});
+			return;
+		}
+		return {
+			...base,
+			kind: "param",
+			name: argument.value
+		};
+	}
+	if (decoratorName === "Headers") {
+		if (argument.value === void 0) {
+			context.diagnostics.push({
+				code: "unsupported-parameter",
+				title: "Unsupported parameter.",
+				controllerName: context.controllerName,
+				memberName: context.methodName,
+				detail: "A whole @Headers() is not supported; provide a header name such as @Headers('x-example').",
+				filePath: context.filePath,
+				line: location.line,
+				column: location.column
+			});
+			return;
+		}
+		return {
+			...base,
+			kind: "header",
+			name: argument.value
+		};
+	}
+	if (decoratorName === "Query") return {
+		...base,
+		kind: "query",
+		name: argument.value
+	};
+	return {
+		...base,
+		kind: "body",
+		name: argument.value
+	};
+};
+var PRIMITIVE_SCALAR_TYPES = {
+	string: "String",
+	number: "Float",
+	boolean: "Boolean"
+};
+var unwrapPromise = (typeNode) => {
+	if (isTypeReferenceNode(typeNode) && isIdentifier(typeNode.typeName) && typeNode.typeName.text === "Promise" && typeNode.typeArguments?.[0] !== void 0) return unwrapPromise(typeNode.typeArguments[0]);
+	return typeNode;
+};
+var unwrapNullable = (typeNode) => {
+	if (!isUnionTypeNode(typeNode)) return {
+		inner: typeNode,
+		isNullable: false
+	};
+	const nonNullMembers = typeNode.types.filter((member) => member.kind !== SyntaxKind.NullKeyword && member.kind !== SyntaxKind.UndefinedKeyword);
+	const [onlyMember] = nonNullMembers;
+	if (nonNullMembers.length !== 1 || onlyMember === void 0) return {
+		inner: typeNode,
+		isNullable: nonNullMembers.length !== typeNode.types.length
+	};
+	return {
+		inner: onlyMember,
+		isNullable: true
+	};
+};
+var unwrapArrayElement = (typeNode) => {
+	if (isArrayTypeNode(typeNode)) return typeNode.elementType;
+	if (isTypeReferenceNode(typeNode) && isIdentifier(typeNode.typeName) && typeNode.typeName.text === "Array" && typeNode.typeArguments?.[0] !== void 0) return typeNode.typeArguments[0];
+};
+var identifierTextOf = (typeNode) => {
+	if (isTypeReferenceNode(typeNode) && isIdentifier(typeNode.typeName)) return typeNode.typeName.text;
+	switch (typeNode.kind) {
+		case SyntaxKind.StringKeyword: return "string";
+		case SyntaxKind.NumberKeyword: return "number";
+		case SyntaxKind.BooleanKeyword: return "boolean";
+		default: return;
+	}
+};
+var unwrapTypeNode = (typeNode) => {
+	const { inner: withoutNullable, isNullable } = unwrapNullable(unwrapPromise(typeNode));
+	const arrayElement = unwrapArrayElement(withoutNullable);
+	const identifierText = identifierTextOf(arrayElement === void 0 ? withoutNullable : unwrapNullable(arrayElement).inner);
+	if (identifierText === void 0) return;
+	return {
+		identifierText,
+		isArray: arrayElement !== void 0,
+		isNullable
+	};
+};
+var graphqlScalarNameFor = (identifierText) => PRIMITIVE_SCALAR_TYPES[identifierText] ?? identifierText;
+var graphqlTypeStringFor = (unwrapped, explicitTypeName) => {
+	const baseName = explicitTypeName ?? graphqlScalarNameFor(unwrapped.identifierText);
+	const wrapped = unwrapped.isArray ? `[${baseName}!]` : baseName;
+	return unwrapped.isNullable ? wrapped : `${wrapped}!`;
+};
+var OBSERVABLE_TYPE_NAME = "Observable";
+var STREAMABLE_FILE_TYPE_NAME = "StreamableFile";
+var readResponseKind = (returnType) => {
+	if (returnType === void 0) return "json";
+	const unwrapped = unwrapPromise(returnType);
+	if (!isTypeReferenceNode(unwrapped) || !isIdentifier(unwrapped.typeName)) return "json";
+	if (unwrapped.typeName.text === OBSERVABLE_TYPE_NAME) return "observable";
+	if (unwrapped.typeName.text === STREAMABLE_FILE_TYPE_NAME) return "stream";
+	return "json";
+};
+var trimSlashes = (segment) => segment.replace(/^\/+/, "").replace(/\/+$/, "");
+var joinRoutePath = (controllerPath, methodPath) => {
+	return `/${[trimSlashes(controllerPath), trimSlashes(methodPath ?? "")].filter((segment) => segment.length > 0).join("/")}`;
+};
+var extractMethodDefinition = (method, context) => {
+	const decorator = findAnyDecorator(method, Object.keys(HTTP_METHOD_DECORATOR_NAMES));
+	if (decorator === void 0) return;
+	const methodName = method.name.getText();
+	const decoratorName = decoratorNameOf(decorator);
+	const location = locationOf(context.sourceFile, method);
+	if (decoratorName === void 0) return;
+	const httpMethod = HTTP_METHOD_DECORATOR_NAMES[decoratorName];
+	if (httpMethod === void 0) return;
+	const routeArgument = readStaticStringArgument(decorator);
+	if (!routeArgument.ok) {
+		context.diagnostics.push({
+			code: "unsupported-route",
+			title: "Unsupported route.",
+			controllerName: context.controllerName,
+			memberName: methodName,
+			detail: "Route paths must be statically analyzable.",
+			found: `@${decoratorName}(${routeArgument.argumentText})`,
+			filePath: context.filePath,
+			line: location.line,
+			column: location.column
+		});
+		return;
+	}
+	const parameters = method.parameters.map((parameter, index) => extractParameterDefinition(parameter, index, {
+		sourceFile: context.sourceFile,
+		filePath: context.filePath,
+		controllerName: context.controllerName,
+		methodName,
+		diagnostics: context.diagnostics
+	}));
+	if (parameters.some((parameter) => parameter === void 0)) return;
+	return {
+		name: methodName,
+		httpMethod,
+		path: joinRoutePath(context.controllerPath, routeArgument.value),
+		parameters: parameters.filter((parameter) => parameter !== void 0),
+		responseKind: readResponseKind(method.type),
+		line: location.line,
+		column: location.column
+	};
+};
+var extractControllerDefinition = (classDeclaration, sourceFile, filePath, diagnostics) => {
+	const controllerName = classDeclaration.name?.text ?? "(anonymous controller)";
+	const decorator = findDecorator(classDeclaration, "Controller");
+	if (decorator === void 0) return;
+	const location = locationOf(sourceFile, classDeclaration);
+	const argument = readStaticStringArgument(decorator);
+	if (!argument.ok) {
+		diagnostics.push({
+			code: "unsupported-route",
+			title: "Unsupported route.",
+			controllerName,
+			memberName: "",
+			detail: "Controller paths must be statically analyzable.",
+			found: `@Controller(${argument.argumentText})`,
+			filePath,
+			line: location.line,
+			column: location.column
+		});
+		return;
+	}
+	const methods = classDeclaration.members.filter((member) => isMethodDeclaration(member)).map((method) => extractMethodDefinition(method, {
+		sourceFile,
+		filePath,
+		controllerName,
+		controllerPath: argument.value ?? "",
+		diagnostics
+	})).filter((method) => method !== void 0);
+	return {
+		name: controllerName,
+		path: argument.value ?? "",
+		sourceFile: filePath,
+		methods
+	};
+};
+var findControllerClasses = (sourceFile) => {
+	return sourceFile.statements.filter((statement) => isClassDeclaration(statement) && findDecorator(statement, "Controller") !== void 0);
+};
+var sharedApi;
+var parseSourceFile = (filePath) => {
+	sharedApi ??= new API();
+	sharedApi.updateSnapshot({ closeFiles: [filePath] });
+	const sourceFile = sharedApi.updateSnapshot({
+		openFiles: [filePath],
+		fileChanges: { changed: [filePath] }
+	}).getDefaultProjectForFile(filePath)?.program.getSourceFile(filePath);
+	if (sourceFile === void 0) throw new Error(`Unable to parse source file: ${filePath}`);
+	return sourceFile;
+};
+var analyzeControllers = (filePaths) => {
+	const diagnostics = [];
+	const controllers = [];
+	for (const filePath of filePaths) {
+		const sourceFile = parseSourceFile(filePath);
+		for (const classDeclaration of findControllerClasses(sourceFile)) {
+			const controller = extractControllerDefinition(classDeclaration, sourceFile, filePath, diagnostics);
+			if (controller !== void 0) controllers.push(controller);
+		}
+	}
+	return {
+		controllers,
+		diagnostics
+	};
+};
+var GRAPHQL_OPERATION_DECORATOR_NAMES = {
+	Query: "query",
+	Mutation: "mutation"
+};
+var readTypeThunkExpression = (thunk) => {
+	if (!isBlock(thunk.body)) return thunk.body;
+	return thunk.body.statements.find(isReturnStatement)?.expression;
+};
+var readArgsTypeOption = (decorator) => {
+	if (!isCallExpression(decorator.expression)) return;
+	const optionsArgument = decorator.expression.arguments.find(isObjectLiteralExpression);
+	if (optionsArgument === void 0) return;
+	const typeProperty = optionsArgument.properties.find((property) => isPropertyAssignment(property) && isIdentifier(property.name) && property.name.text === "type");
+	if (typeProperty === void 0) return;
+	const thunk = typeProperty.initializer;
+	if (!isArrowFunction(thunk) && !isFunctionExpression(thunk)) return;
+	const returnedExpression = readTypeThunkExpression(thunk);
+	if (returnedExpression === void 0) return;
+	if (isArrayLiteralExpression(returnedExpression)) {
+		const element = returnedExpression.elements[0];
+		return element !== void 0 && isIdentifier(element) ? {
+			typeName: element.text,
+			isArray: true
+		} : void 0;
+	}
+	return isIdentifier(returnedExpression) ? {
+		typeName: returnedExpression.text,
+		isArray: false
+	} : void 0;
+};
+var extractResolverArgumentDefinition = (parameter, index, context) => {
+	const decorator = findAnyDecorator(parameter, ["Args"]);
+	const location = locationOf(context.sourceFile, parameter);
+	if (decorator === void 0) {
+		context.diagnostics.push({
+			code: "unsupported-argument",
+			title: "Unsupported argument.",
+			controllerName: context.resolverName,
+			memberName: context.methodName,
+			detail: `Parameter "${parameter.name.getText()}" must be decorated with @Args to be transported through a NestBridge GraphQL client.`,
+			filePath: context.filePath,
+			line: location.line,
+			column: location.column
+		});
+		return;
+	}
+	if (!isIdentifier(parameter.name)) {
+		context.diagnostics.push({
+			code: "unsupported-argument",
+			title: "Unsupported argument.",
+			controllerName: context.resolverName,
+			memberName: context.methodName,
+			detail: "Destructured parameters cannot be transported through a NestBridge GraphQL client.",
+			filePath: context.filePath,
+			line: location.line,
+			column: location.column
+		});
+		return;
+	}
+	const nameArgument = readStaticStringArgument(decorator);
+	if (!nameArgument.ok) {
+		context.diagnostics.push({
+			code: "unsupported-argument",
+			title: "Unsupported argument.",
+			controllerName: context.resolverName,
+			memberName: context.methodName,
+			detail: "@Args() name must be a statically analyzable string literal.",
+			found: `@Args(${nameArgument.argumentText})`,
+			filePath: context.filePath,
+			line: location.line,
+			column: location.column
+		});
+		return;
+	}
+	if (nameArgument.value === void 0) {
+		context.diagnostics.push({
+			code: "unsupported-argument",
+			title: "Unsupported argument.",
+			controllerName: context.resolverName,
+			memberName: context.methodName,
+			detail: "A whole @Args() is not supported; provide an argument name such as @Args('id').",
+			filePath: context.filePath,
+			line: location.line,
+			column: location.column
+		});
+		return;
+	}
+	if (parameter.type === void 0) {
+		context.diagnostics.push({
+			code: "unsupported-argument",
+			title: "Unsupported argument.",
+			controllerName: context.resolverName,
+			memberName: context.methodName,
+			detail: `@Args() parameter "${parameter.name.text}" needs an explicit type annotation.`,
+			filePath: context.filePath,
+			line: location.line,
+			column: location.column
+		});
+		return;
+	}
+	const unwrapped = unwrapTypeNode(parameter.type);
+	if (unwrapped === void 0) {
+		context.diagnostics.push({
+			code: "unsupported-argument",
+			title: "Unsupported argument.",
+			controllerName: context.resolverName,
+			memberName: context.methodName,
+			detail: `@Args() parameter "${parameter.name.text}" has a type NestBridge cannot statically resolve to a GraphQL type.`,
+			found: parameter.type.getText(),
+			filePath: context.filePath,
+			line: location.line,
+			column: location.column
+		});
+		return;
+	}
+	const explicitType = readArgsTypeOption(decorator);
+	return {
+		index,
+		parameterName: parameter.name.text,
+		name: nameArgument.value,
+		graphqlType: graphqlTypeStringFor(unwrapped, explicitType?.typeName)
+	};
+};
+var parsedFilesByPath = /* @__PURE__ */ new Map();
+var parseFile = (filePath) => {
+	const cached = parsedFilesByPath.get(filePath);
+	if (cached !== void 0) return cached;
+	const sourceFile = parseSourceFile(filePath);
+	parsedFilesByPath.set(filePath, sourceFile);
+	return sourceFile;
+};
+var resolveModuleFile = (fromFilePath, moduleSpecifierText) => {
+	if (!moduleSpecifierText.startsWith(".")) return;
+	const base = resolve(dirname(fromFilePath), moduleSpecifierText);
+	return [
+		`${base}.ts`,
+		`${base}.tsx`,
+		resolve(base, "index.ts")
+	].find((candidate) => existsSync(candidate));
+};
+var findExportedDeclaration = (sourceFile, name) => sourceFile.statements.find((statement) => isClassDeclaration(statement) && statement.name?.text === name);
+var findImportSource = (sourceFile, localName) => {
+	for (const statement of sourceFile.statements) {
+		if (!isImportDeclaration(statement) || !isStringLiteralLikeNode(statement.moduleSpecifier)) continue;
+		const namedBindings = statement.importClause?.namedBindings;
+		if (namedBindings === void 0 || !isNamedImports(namedBindings)) continue;
+		const element = namedBindings.elements.find((candidate) => candidate.name.text === localName);
+		if (element !== void 0) return {
+			moduleSpecifierText: statement.moduleSpecifier.text,
+			importedName: element.propertyName?.text ?? element.name.text
+		};
+	}
+};
+var findReExportSource = (sourceFile, name) => {
+	for (const statement of sourceFile.statements) {
+		if (!isExportDeclaration(statement) || statement.moduleSpecifier === void 0 || !isStringLiteralLikeNode(statement.moduleSpecifier)) continue;
+		if (statement.exportClause === void 0) return statement.moduleSpecifier.text;
+		if (isNamedExports(statement.exportClause) && statement.exportClause.elements.some((element) => (element.propertyName?.text ?? element.name.text) === name)) return statement.moduleSpecifier.text;
+	}
+};
+var resolveClassDeclaration = (name, fromSourceFile, fromFilePath, visited = /* @__PURE__ */ new Set()) => {
+	if (visited.has(fromFilePath)) return;
+	visited.add(fromFilePath);
+	const direct = findExportedDeclaration(fromSourceFile, name);
+	if (direct !== void 0) return {
+		classDeclaration: direct,
+		sourceFile: fromSourceFile,
+		filePath: fromFilePath
+	};
+	const importSource = findImportSource(fromSourceFile, name);
+	if (importSource !== void 0) {
+		const resolvedPath = resolveModuleFile(fromFilePath, importSource.moduleSpecifierText);
+		if (resolvedPath !== void 0) {
+			const nextSourceFile = parseFile(resolvedPath);
+			const result = resolveClassDeclaration(importSource.importedName, nextSourceFile, resolvedPath, visited);
+			if (result !== void 0) return result;
+		}
+	}
+	const reExportModuleSpecifierText = findReExportSource(fromSourceFile, name);
+	if (reExportModuleSpecifierText !== void 0) {
+		const resolvedPath = resolveModuleFile(fromFilePath, reExportModuleSpecifierText);
+		if (resolvedPath !== void 0) return resolveClassDeclaration(name, parseFile(resolvedPath), resolvedPath, visited);
+	}
+};
+var PRIMITIVE_SCALAR_NAMES$1 = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"boolean"
+]);
+var extractSelectionFields = (classDeclaration, sourceFile, filePath, context) => {
+	const typeName = classDeclaration.name?.text ?? "(anonymous type)";
+	const location = locationOf(sourceFile, classDeclaration);
+	if (context.visitedTypeNames.has(typeName)) {
+		context.diagnostics.push({
+			code: "circular-type",
+			title: "Circular type.",
+			controllerName: context.resolverName,
+			memberName: context.methodName,
+			detail: `Type "${typeName}" references itself, directly or indirectly. NestBridge cannot build a finite GraphQL selection set for it.`,
+			filePath,
+			line: location.line,
+			column: location.column
+		});
+		return;
+	}
+	const nextVisited = new Set(context.visitedTypeNames).add(typeName);
+	const properties = classDeclaration.members.filter((member) => isPropertyDeclaration(member) && findDecorator(member, "Field") !== void 0);
+	const fields = [];
+	for (const property of properties) {
+		if (!isIdentifier(property.name)) continue;
+		const fieldName = property.name.text;
+		const fieldLocation = locationOf(sourceFile, property);
+		if (property.type === void 0) {
+			context.diagnostics.push({
+				code: "unsupported-return-type",
+				title: "Unsupported field type.",
+				controllerName: context.resolverName,
+				memberName: context.methodName,
+				detail: `Field "${fieldName}" on "${typeName}" needs an explicit type annotation.`,
+				filePath,
+				line: fieldLocation.line,
+				column: fieldLocation.column
+			});
+			return;
+		}
+		const unwrapped = unwrapTypeNode(property.type);
+		if (unwrapped === void 0) {
+			context.diagnostics.push({
+				code: "unsupported-return-type",
+				title: "Unsupported field type.",
+				controllerName: context.resolverName,
+				memberName: context.methodName,
+				detail: `Field "${fieldName}" on "${typeName}" has a type NestBridge cannot statically resolve.`,
+				found: property.type.getText(),
+				filePath,
+				line: fieldLocation.line,
+				column: fieldLocation.column
+			});
+			return;
+		}
+		if (PRIMITIVE_SCALAR_NAMES$1.has(unwrapped.identifierText)) {
+			fields.push({ name: fieldName });
+			continue;
+		}
+		const resolved = resolveClassDeclaration(unwrapped.identifierText, sourceFile, filePath);
+		if (resolved === void 0) {
+			fields.push({ name: fieldName });
+			continue;
+		}
+		if (findDecorator(resolved.classDeclaration, "ObjectType") === void 0) {
+			context.diagnostics.push({
+				code: "unsupported-return-type",
+				title: "Unsupported field type.",
+				controllerName: context.resolverName,
+				memberName: context.methodName,
+				detail: `Field "${fieldName}" on "${typeName}" resolves to class "${unwrapped.identifierText}", which is not decorated with @ObjectType(). NestBridge cannot build a GraphQL selection set for it.`,
+				filePath,
+				line: fieldLocation.line,
+				column: fieldLocation.column
+			});
+			return;
+		}
+		const children = extractSelectionFields(resolved.classDeclaration, resolved.sourceFile, resolved.filePath, {
+			...context,
+			visitedTypeNames: nextVisited
+		});
+		if (children === void 0) return;
+		fields.push({
+			name: fieldName,
+			children
+		});
+	}
+	return fields;
+};
+var readNameFromOptions = (optionsArgument) => {
+	const nameProperty = optionsArgument.properties.find((property) => isPropertyAssignment(property) && isIdentifier(property.name) && property.name.text === "name");
+	if (nameProperty === void 0 || !isStringLiteralLikeNode(nameProperty.initializer)) return;
+	return nameProperty.initializer.text;
+};
+var readGraphqlOperationName = (decorator) => {
+	const expression = decorator.expression;
+	if (!isCallExpression(expression)) return {
+		ok: true,
+		value: void 0
+	};
+	let value;
+	for (const argument of expression.arguments) {
+		if (isArrowFunction(argument) || isFunctionExpression(argument)) continue;
+		if (isStringLiteralLikeNode(argument)) {
+			value = argument.text;
+			continue;
+		}
+		if (isObjectLiteralExpression(argument)) {
+			value = readNameFromOptions(argument) ?? value;
+			continue;
+		}
+		return {
+			ok: false,
+			argumentText: argument.getText()
+		};
+	}
+	return {
+		ok: true,
+		value
+	};
+};
+var readGraphqlReturnTypeOption = (decorator) => {
+	if (!isCallExpression(decorator.expression)) return;
+	const thunk = decorator.expression.arguments.find((argument) => isArrowFunction(argument) || isFunctionExpression(argument));
+	if (thunk === void 0) return;
+	const returnedExpression = readTypeThunkExpression(thunk);
+	if (returnedExpression === void 0) return;
+	if (isArrayLiteralExpression(returnedExpression)) {
+		const element = returnedExpression.elements[0];
+		return element !== void 0 && isIdentifier(element) ? element.text : void 0;
+	}
+	return isIdentifier(returnedExpression) ? returnedExpression.text : void 0;
+};
+var PRIMITIVE_SCALAR_NAMES = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"boolean"
+]);
+var extractResolverMethodDefinition = (method, context) => {
+	const decorator = findAnyDecorator(method, Object.keys(GRAPHQL_OPERATION_DECORATOR_NAMES));
+	if (decorator === void 0) return;
+	const methodName = method.name.getText();
+	const decoratorName = decoratorNameOf(decorator);
+	const location = locationOf(context.sourceFile, method);
+	if (decoratorName === void 0) return;
+	const operationKind = GRAPHQL_OPERATION_DECORATOR_NAMES[decoratorName];
+	if (operationKind === void 0) return;
+	const nameArgument = readGraphqlOperationName(decorator);
+	if (!nameArgument.ok) {
+		context.diagnostics.push({
+			code: "unsupported-route",
+			title: "Unsupported operation name.",
+			controllerName: context.resolverName,
+			memberName: methodName,
+			detail: "GraphQL operation names must be statically analyzable string literals.",
+			found: `@${decoratorName}(${nameArgument.argumentText})`,
+			filePath: context.filePath,
+			line: location.line,
+			column: location.column
+		});
+		return;
+	}
+	const decoratorReturnType = readGraphqlReturnTypeOption(decorator);
+	const identifierText = decoratorReturnType ?? (method.type === void 0 ? void 0 : unwrapTypeNode(method.type)?.identifierText);
+	if (identifierText === void 0) {
+		context.diagnostics.push({
+			code: "unsupported-return-type",
+			title: "Unsupported return type.",
+			controllerName: context.resolverName,
+			memberName: methodName,
+			detail: "GraphQL resolver methods need a type thunk on @Query()/@Mutation() (e.g. \"() => UserType\") or an explicit return type annotation so NestBridge can build a selection set.",
+			filePath: context.filePath,
+			line: location.line,
+			column: location.column
+		});
+		return;
+	}
+	let selection = [];
+	if (!PRIMITIVE_SCALAR_NAMES.has(identifierText.toLowerCase())) {
+		const resolved = resolveClassDeclaration(identifierText, context.sourceFile, context.filePath);
+		if (resolved === void 0 && decoratorReturnType === void 0) {
+			context.diagnostics.push({
+				code: "unsupported-return-type",
+				title: "Unsupported return type.",
+				controllerName: context.resolverName,
+				memberName: methodName,
+				detail: `NestBridge could not locate the declaration of type "${identifierText}".`,
+				filePath: context.filePath,
+				line: location.line,
+				column: location.column
+			});
+			return;
+		}
+		if (resolved !== void 0) {
+			const fields = extractSelectionFields(resolved.classDeclaration, resolved.sourceFile, resolved.filePath, {
+				resolverName: context.resolverName,
+				methodName,
+				diagnostics: context.diagnostics,
+				visitedTypeNames: /* @__PURE__ */ new Set()
+			});
+			if (fields === void 0) return;
+			selection = fields;
+		}
+	}
+	const args = method.parameters.map((parameter, index) => extractResolverArgumentDefinition(parameter, index, {
+		sourceFile: context.sourceFile,
+		filePath: context.filePath,
+		resolverName: context.resolverName,
+		methodName,
+		diagnostics: context.diagnostics
+	}));
+	if (args.some((argument) => argument === void 0)) return;
+	return {
+		name: methodName,
+		operationKind,
+		operationName: nameArgument.value ?? methodName,
+		arguments: args.filter((argument) => argument !== void 0),
+		selection,
+		line: location.line,
+		column: location.column
+	};
+};
+var extractResolverDefinition = (classDeclaration, sourceFile, filePath, diagnostics) => {
+	const resolverName = classDeclaration.name?.text ?? "(anonymous resolver)";
+	return {
+		name: resolverName,
+		sourceFile: filePath,
+		methods: classDeclaration.members.filter((member) => isMethodDeclaration(member)).map((method) => extractResolverMethodDefinition(method, {
+			sourceFile,
+			filePath,
+			resolverName,
+			diagnostics
+		})).filter((method) => method !== void 0)
+	};
+};
+var findResolverClasses = (sourceFile) => {
+	return sourceFile.statements.filter((statement) => isClassDeclaration(statement) && findDecorator(statement, "Resolver") !== void 0);
+};
+var analyzeResolvers = (filePaths) => {
+	const diagnostics = [];
+	const resolvers = [];
+	for (const filePath of filePaths) {
+		const sourceFile = parseSourceFile(filePath);
+		for (const classDeclaration of findResolverClasses(sourceFile)) {
+			const resolver = extractResolverDefinition(classDeclaration, sourceFile, filePath, diagnostics);
+			if (resolver !== void 0) resolvers.push(resolver);
+		}
+	}
+	return {
+		resolvers,
+		diagnostics
+	};
+};
+var MODULE_DECORATOR_NAME = "Module";
+var PROVIDERS_PROPERTY_NAME = "providers";
+var PROVIDE_PROPERTY_NAME = "provide";
+var USE_CLASS_PROPERTY_NAME = "useClass";
+var APP_FILTER_LOCAL_NAME = "APP_FILTER";
+var NEST_CORE_MODULE_SPECIFIER$1 = "@nestjs/core";
+var findAppFilterProviderClassName = (moduleClassDeclaration, moduleSourceFile) => {
+	const moduleDecorator = findDecorator(moduleClassDeclaration, MODULE_DECORATOR_NAME);
+	if (moduleDecorator === void 0 || !isCallExpression(moduleDecorator.expression)) return;
+	const [moduleOptions] = moduleDecorator.expression.arguments;
+	if (moduleOptions === void 0 || !isObjectLiteralExpression(moduleOptions)) return;
+	const providersProperty = moduleOptions.properties.find((property) => isPropertyAssignment(property) && isIdentifier(property.name) && property.name.text === PROVIDERS_PROPERTY_NAME);
+	if (providersProperty === void 0 || !isArrayLiteralExpression(providersProperty.initializer)) return;
+	const appFilterImportSource = findImportSource(moduleSourceFile, APP_FILTER_LOCAL_NAME);
+	if (appFilterImportSource === void 0 || appFilterImportSource.moduleSpecifierText !== NEST_CORE_MODULE_SPECIFIER$1) return;
+	const classNames = /* @__PURE__ */ new Set();
+	for (const element of providersProperty.initializer.elements) {
+		if (isSpreadElement(element)) return;
+		if (!isObjectLiteralExpression(element)) continue;
+		const provideProperty = element.properties.find((property) => isPropertyAssignment(property) && isIdentifier(property.name) && property.name.text === PROVIDE_PROPERTY_NAME);
+		if (provideProperty === void 0 || !isIdentifier(provideProperty.initializer) || provideProperty.initializer.text !== APP_FILTER_LOCAL_NAME) continue;
+		const useClassProperty = element.properties.find((property) => isPropertyAssignment(property) && isIdentifier(property.name) && property.name.text === USE_CLASS_PROPERTY_NAME);
+		if (useClassProperty === void 0 || !isIdentifier(useClassProperty.initializer)) return;
+		classNames.add(useClassProperty.initializer.text);
+	}
+	return classNames.size === 1 ? [...classNames][0] : void 0;
+};
+var USE_GLOBAL_FILTERS_METHOD_NAME = "useGlobalFilters";
+var collectUseGlobalFiltersCalls = (node, calls) => {
+	if (isCallExpression(node) && isPropertyAccessExpression(node.expression) && node.expression.name.text === USE_GLOBAL_FILTERS_METHOD_NAME) calls.push(node);
+	node.forEachChild((child) => {
+		collectUseGlobalFiltersCalls(child, calls);
+	});
+};
+var findGlobalFilterClassName = (sourceFile) => {
+	const calls = [];
+	collectUseGlobalFiltersCalls(sourceFile, calls);
+	if (calls.length === 0) return;
+	const classNames = /* @__PURE__ */ new Set();
+	for (const call of calls) for (const argument of call.arguments) {
+		if (!isNewExpression(argument) || !isIdentifier(argument.expression)) return;
+		classNames.add(argument.expression.text);
+	}
+	return classNames.size === 1 ? [...classNames][0] : void 0;
+};
+var NEST_FACTORY_LOCAL_NAME = "NestFactory";
+var NEST_FACTORY_CREATE_METHOD_NAME = "create";
+var NEST_CORE_MODULE_SPECIFIER = "@nestjs/core";
+var collectNestFactoryCreateCalls = (node, calls) => {
+	if (isCallExpression(node) && isPropertyAccessExpression(node.expression) && isIdentifier(node.expression.expression) && node.expression.expression.text === NEST_FACTORY_LOCAL_NAME && node.expression.name.text === NEST_FACTORY_CREATE_METHOD_NAME) calls.push(node);
+	node.forEachChild((child) => {
+		collectNestFactoryCreateCalls(child, calls);
+	});
+};
+var findRootModuleClassName = (sourceFile) => {
+	const nestFactoryImportSource = findImportSource(sourceFile, NEST_FACTORY_LOCAL_NAME);
+	if (nestFactoryImportSource === void 0 || nestFactoryImportSource.moduleSpecifierText !== NEST_CORE_MODULE_SPECIFIER) return;
+	const calls = [];
+	collectNestFactoryCreateCalls(sourceFile, calls);
+	if (calls.length !== 1) return;
+	const [call] = calls;
+	if (call === void 0) return;
+	const [moduleArgument] = call.arguments;
+	return moduleArgument !== void 0 && isIdentifier(moduleArgument) ? moduleArgument.text : void 0;
+};
+var RESPONSE_BODY_CALL_NAMES = /* @__PURE__ */ new Set(["json", "send"]);
+var matchResponseBodyArgument = (expression) => {
+	if (!isCallExpression(expression) || !isPropertyAccessExpression(expression.expression) || !RESPONSE_BODY_CALL_NAMES.has(expression.expression.name.text) || expression.arguments.length !== 1) return;
+	const [argument] = expression.arguments;
+	return argument;
+};
+var resolveCatchMethodBody = (catchMethod) => {
+	const [exceptionParameter] = catchMethod.parameters;
+	if (exceptionParameter === void 0 || !isIdentifier(exceptionParameter.name)) return;
+	const body = catchMethod.body;
+	if (body === void 0) return;
+	const localDeclarations = /* @__PURE__ */ new Map();
+	let responseBodyArgument;
+	let sawResponseCall = false;
+	let sawTrailingReturn = false;
+	for (const statement of body.statements) {
+		if (sawTrailingReturn) return;
+		if (!sawResponseCall && isVariableStatement(statement)) {
+			for (const declaration of statement.declarationList.declarations) {
+				if (!isIdentifier(declaration.name) || declaration.initializer === void 0) return;
+				localDeclarations.set(declaration.name.text, declaration.initializer);
+			}
+			continue;
+		}
+		if (!sawResponseCall && isExpressionStatement(statement)) {
+			const argument = matchResponseBodyArgument(statement.expression);
+			if (argument === void 0) return;
+			responseBodyArgument = argument;
+			sawResponseCall = true;
+			continue;
+		}
+		if (sawResponseCall && isReturnStatement(statement) && statement.expression === void 0) {
+			sawTrailingReturn = true;
+			continue;
+		}
+		return;
+	}
+	if (!sawResponseCall || responseBodyArgument === void 0) return;
+	return {
+		exceptionParameterName: exceptionParameter.name.text,
+		localDeclarations,
+		responseBodyArgument
+	};
+};
+var EXCEPTION_MESSAGE_MEMBER_NAME = "message";
+var EXCEPTION_STATUS_METHOD_NAME = "getStatus";
+var resolvesToExceptionParameter = (expression, exceptionParameterName, localDeclarations, visited) => {
+	if (!isIdentifier(expression)) return false;
+	if (expression.text === exceptionParameterName) return true;
+	if (visited.has(expression.text)) return false;
+	visited.add(expression.text);
+	const aliasedExpression = localDeclarations.get(expression.text);
+	return aliasedExpression !== void 0 ? resolvesToExceptionParameter(aliasedExpression, exceptionParameterName, localDeclarations, visited) : false;
+};
+var synthesizeErrorValueType = (expression, exceptionParameterName, localDeclarations) => {
+	if (isPropertyAccessExpression(expression) && expression.name.text === EXCEPTION_MESSAGE_MEMBER_NAME && resolvesToExceptionParameter(expression.expression, exceptionParameterName, localDeclarations, /* @__PURE__ */ new Set())) return "string";
+	if (isCallExpression(expression) && expression.arguments.length === 0 && isPropertyAccessExpression(expression.expression) && expression.expression.name.text === EXCEPTION_STATUS_METHOD_NAME && resolvesToExceptionParameter(expression.expression.expression, exceptionParameterName, localDeclarations, /* @__PURE__ */ new Set())) return "number";
+	if (isObjectLiteralExpression(expression)) {
+		const memberTypes = [];
+		for (const property of expression.properties) {
+			if (!isPropertyAssignment(property) || !(isIdentifier(property.name) || isStringLiteral(property.name))) return;
+			const valueType = synthesizeErrorValueType(property.initializer, exceptionParameterName, localDeclarations);
+			if (valueType === void 0) return;
+			memberTypes.push(`${property.name.text}: ${valueType}`);
+		}
+		return `{ ${memberTypes.join("; ")} }`;
+	}
+	if (isStringLiteral(expression)) return "string";
+	if (isNumericLiteral(expression)) return "number";
+	if (isTrueLiteral(expression) || isFalseLiteral(expression)) return "boolean";
+	if (isNullLiteral(expression)) return "null";
+	if (isIdentifier(expression)) {
+		const aliasedExpression = localDeclarations.get(expression.text);
+		return aliasedExpression !== void 0 ? synthesizeErrorValueType(aliasedExpression, exceptionParameterName, localDeclarations) : void 0;
+	}
+};
+var synthesizeErrorBodyType = (objectLiteral, exceptionParameterName, localDeclarations) => synthesizeErrorValueType(objectLiteral, exceptionParameterName, localDeclarations);
+var CATCH_DECORATOR_NAME = "Catch";
+var CATCH_METHOD_NAME = "catch";
+var findCatchMethod = (members) => members.find((member) => isMethodDeclaration(member) && isIdentifier(member.name) && member.name.text === CATCH_METHOD_NAME);
+var resolveViaGlobalFilters = (bootstrapSourceFile, bootstrapFilePath) => {
+	const filterClassName = findGlobalFilterClassName(bootstrapSourceFile);
+	return filterClassName === void 0 ? void 0 : resolveClassDeclaration(filterClassName, bootstrapSourceFile, bootstrapFilePath);
+};
+var resolveViaAppFilterProvider = (bootstrapSourceFile, bootstrapFilePath) => {
+	const rootModuleClassName = findRootModuleClassName(bootstrapSourceFile);
+	if (rootModuleClassName === void 0) return;
+	const resolvedModule = resolveClassDeclaration(rootModuleClassName, bootstrapSourceFile, bootstrapFilePath);
+	if (resolvedModule === void 0) return;
+	const filterClassName = findAppFilterProviderClassName(resolvedModule.classDeclaration, resolvedModule.sourceFile);
+	return filterClassName === void 0 ? void 0 : resolveClassDeclaration(filterClassName, resolvedModule.sourceFile, resolvedModule.filePath);
+};
+var isSameDeclaration = (a, b) => a.filePath === b.filePath && a.classDeclaration.name?.text === b.classDeclaration.name?.text;
+var reconcileResolvedFilter = (viaGlobalFilters, viaAppFilterProvider) => {
+	if (viaGlobalFilters !== void 0 && viaAppFilterProvider !== void 0) return isSameDeclaration(viaGlobalFilters, viaAppFilterProvider) ? viaGlobalFilters : void 0;
+	return viaGlobalFilters ?? viaAppFilterProvider;
+};
+var detectErrorResponseShape = (bootstrapFilePath) => {
+	const bootstrapSourceFile = parseSourceFile(bootstrapFilePath);
+	const resolved = reconcileResolvedFilter(resolveViaGlobalFilters(bootstrapSourceFile, bootstrapFilePath), resolveViaAppFilterProvider(bootstrapSourceFile, bootstrapFilePath));
+	if (resolved === void 0 || findDecorator(resolved.classDeclaration, CATCH_DECORATOR_NAME) === void 0) return;
+	const catchMethod = findCatchMethod(resolved.classDeclaration.members);
+	if (catchMethod?.body === void 0) return;
+	const bodyResolution = resolveCatchMethodBody(catchMethod);
+	if (bodyResolution === void 0 || !isObjectLiteralExpression(bodyResolution.responseBodyArgument)) return;
+	const errorBodyTypeSource = synthesizeErrorBodyType(bodyResolution.responseBodyArgument, bodyResolution.exceptionParameterName, bodyResolution.localDeclarations);
+	return errorBodyTypeSource === void 0 ? void 0 : { errorBodyTypeSource };
+};
+var USE_GLOBAL_INTERCEPTORS_METHOD_NAME = "useGlobalInterceptors";
+var collectUseGlobalInterceptorsCalls = (node, calls) => {
+	if (isCallExpression(node) && isPropertyAccessExpression(node.expression) && node.expression.name.text === USE_GLOBAL_INTERCEPTORS_METHOD_NAME) calls.push(node);
+	node.forEachChild((child) => {
+		collectUseGlobalInterceptorsCalls(child, calls);
+	});
+};
+/**
+* Returned in registration order: `useGlobalInterceptors` concatenates onto a
+* single global list, so a later call (or a later argument within one call)
+* always registers an interceptor that wraps closer to the raw handler result.
+*/
+var findGlobalInterceptorClassNames = (sourceFile) => {
+	const calls = [];
+	collectUseGlobalInterceptorsCalls(sourceFile, calls);
+	if (calls.length === 0) return;
+	const classNames = [];
+	for (const call of calls) for (const argument of call.arguments) {
+		if (!isNewExpression(argument) || !isIdentifier(argument.expression)) return;
+		classNames.push(argument.expression.text);
+	}
+	return classNames.length === 0 ? void 0 : classNames;
+};
+var synthesizeExpressionType = (expression, parameterName, substitution, state) => {
+	if (isIdentifier(expression) && expression.text === parameterName) {
+		state.substitutionCount += 1;
+		return substitution;
+	}
+	if (isObjectLiteralExpression(expression)) {
+		const memberTypes = [];
+		for (const property of expression.properties) {
+			if (!isPropertyAssignment(property) || !(isIdentifier(property.name) || isStringLiteral(property.name))) return;
+			const valueType = synthesizeExpressionType(property.initializer, parameterName, substitution, state);
+			if (valueType === void 0) return;
+			memberTypes.push(`${property.name.text}: ${valueType}`);
+		}
+		return `{ ${memberTypes.join("; ")} }`;
+	}
+	if (isStringLiteral(expression)) return "string";
+	if (isNumericLiteral(expression)) return "number";
+	if (isTrueLiteral(expression) || isFalseLiteral(expression)) return "boolean";
+	if (isNullLiteral(expression)) return "null";
+};
+var synthesizeGenericObjectType = (objectLiteral, parameterName, substitution) => {
+	const state = { substitutionCount: 0 };
+	const objectType = synthesizeExpressionType(objectLiteral, parameterName, substitution, state);
+	return objectType !== void 0 && state.substitutionCount === 1 ? objectType : void 0;
+};
+var INTERCEPT_METHOD_NAME = "intercept";
+var PIPE_MEMBER_NAME = "pipe";
+var MAP_OPERATOR_NAME = "map";
+var RXJS_MODULE_SPECIFIER = "rxjs";
+var WRAPPED_RESULT_SUBSTITUTION = "Awaited<Result>";
+var unwrapParenthesizedExpression = (expression) => {
+	let unwrapped = expression;
+	while (isParenthesizedExpression(unwrapped)) unwrapped = unwrapped.expression;
+	return unwrapped;
+};
+var resolveSoleReturnExpression = (body) => {
+	if (!isBlock(body)) return unwrapParenthesizedExpression(body);
+	const localDeclarations = /* @__PURE__ */ new Map();
+	let returnExpression;
+	let sawReturn = false;
+	for (const statement of body.statements) {
+		if (sawReturn) return;
+		if (isVariableStatement(statement)) {
+			for (const declaration of statement.declarationList.declarations) {
+				if (!isIdentifier(declaration.name) || declaration.initializer === void 0) return;
+				localDeclarations.set(declaration.name.text, declaration.initializer);
+			}
+			continue;
+		}
+		if (isReturnStatement(statement)) {
+			sawReturn = true;
+			returnExpression = statement.expression;
+			continue;
+		}
+		return;
+	}
+	if (returnExpression === void 0) return;
+	return isIdentifier(returnExpression) ? localDeclarations.get(returnExpression.text) : returnExpression;
+};
+var matchPipedMapCallback = (expression, interceptorSourceFile) => {
+	if (!isCallExpression(expression) || !isPropertyAccessExpression(expression.expression) || expression.expression.name.text !== PIPE_MEMBER_NAME || expression.arguments.length !== 1) return;
+	const [operator] = expression.arguments;
+	if (operator === void 0 || !isCallExpression(operator) || !isIdentifier(operator.expression) || operator.expression.text !== MAP_OPERATOR_NAME || operator.arguments.length !== 1) return;
+	const mapImportSource = findImportSource(interceptorSourceFile, operator.expression.text);
+	if (mapImportSource === void 0 || mapImportSource.moduleSpecifierText !== RXJS_MODULE_SPECIFIER) return;
+	const [callback] = operator.arguments;
+	return callback !== void 0 && (isArrowFunction(callback) || isFunctionExpression(callback)) ? callback : void 0;
+};
+var findInterceptMethod = (members) => members.find((member) => isMethodDeclaration(member) && isIdentifier(member.name) && member.name.text === INTERCEPT_METHOD_NAME);
+var synthesizeInterceptorWrapperType = (interceptorClassName, bootstrapSourceFile, bootstrapFilePath, innerTypeSource) => {
+	const resolved = resolveClassDeclaration(interceptorClassName, bootstrapSourceFile, bootstrapFilePath);
+	if (resolved === void 0) return;
+	const interceptMethod = findInterceptMethod(resolved.classDeclaration.members);
+	if (interceptMethod?.body === void 0) return;
+	const returnExpression = resolveSoleReturnExpression(interceptMethod.body);
+	if (returnExpression === void 0) return;
+	const mapCallback = matchPipedMapCallback(returnExpression, resolved.sourceFile);
+	if (mapCallback === void 0 || mapCallback.parameters.length !== 1) return;
+	const [callbackParameter] = mapCallback.parameters;
+	if (callbackParameter === void 0 || !isIdentifier(callbackParameter.name)) return;
+	const callbackReturnExpression = resolveSoleReturnExpression(mapCallback.body);
+	if (callbackReturnExpression === void 0 || !isObjectLiteralExpression(callbackReturnExpression)) return;
+	return synthesizeGenericObjectType(callbackReturnExpression, callbackParameter.name.text, innerTypeSource);
+};
+/**
+* Interceptors registered first wrap those registered after them, so the
+* composed type is built from the last-registered interceptor (closest to the
+* raw handler result) outward to the first-registered one.
+*/
+var detectResponseWrapper = (bootstrapFilePath) => {
+	const bootstrapSourceFile = parseSourceFile(bootstrapFilePath);
+	const interceptorClassNames = findGlobalInterceptorClassNames(bootstrapSourceFile);
+	if (interceptorClassNames === void 0) return;
+	let composedTypeSource = WRAPPED_RESULT_SUBSTITUTION;
+	for (const interceptorClassName of [...interceptorClassNames].reverse()) {
+		const wrapperTypeSource = synthesizeInterceptorWrapperType(interceptorClassName, bootstrapSourceFile, bootstrapFilePath, composedTypeSource);
+		if (wrapperTypeSource === void 0) return;
+		composedTypeSource = wrapperTypeSource;
+	}
+	return { wrappedResultTypeSource: composedTypeSource };
+};
+var REMOTE_RESULT_HELPERS = {
+	json: "RemoteResult",
+	observable: "RemoteObservableResult",
+	stream: "RemoteStreamResult"
+};
+var WRAPPED_RESULT_HELPER = "__NestBridgeWrapped";
+var toPosixPath = (filePath) => filePath.replace(/\\/g, "/");
+var importSpecifierFor = (sourceFile, outputFilePath) => {
+	if (!sourceFile.startsWith(".") && !/^[A-Za-z]:[\\/]/.test(sourceFile) && !sourceFile.startsWith("/")) return sourceFile;
+	const relativePath = toPosixPath(relative(dirname(outputFilePath), sourceFile));
+	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+};
+var stripExtension = (filePath) => {
+	const extension = extname(filePath);
+	return extension.length > 0 ? filePath.slice(0, -extension.length) : filePath;
+};
+var generateControllerDeclaration = (controller, outputFilePath, responseWrapper) => {
+	const sourceFileSpecifier = importSpecifierFor(controller.sourceFile, outputFilePath);
+	const importSpecifier = stripExtension(sourceFileSpecifier);
+	const serverAlias = `__Server${controller.name}`;
+	const helperNameFor = (method) => responseWrapper !== void 0 && (method.responseKind ?? "json") === "json" ? WRAPPED_RESULT_HELPER : REMOTE_RESULT_HELPERS[method.responseKind ?? "json"];
+	const classBody = [
+		"  constructor();",
+		"",
+		...controller.methods.map((method) => {
+			const helperName = helperNameFor(method);
+			return `  ${method.name}(...args: Parameters<${serverAlias}['${method.name}']>): ${helperName}<${serverAlias}['${method.name}']>;`;
+		})
+	].join("\n");
+	const rawHelperNames = controller.methods.map((method) => helperNameFor(method));
+	const hasWrappedMethod = rawHelperNames.includes(WRAPPED_RESULT_HELPER);
+	const helperImports = rawHelperNames.length === 0 ? ["RemoteResult"] : Array.from(new Set(rawHelperNames.filter((name) => name !== WRAPPED_RESULT_HELPER))).sort();
+	const wrappedResultTypeAliasLines = responseWrapper !== void 0 && hasWrappedMethod ? [`type ${WRAPPED_RESULT_HELPER}<T> = T extends (...args: never[]) => infer Result ? Promise<${responseWrapper.wrappedResultTypeSource}> : never;`, ""] : [];
+	return [
+		`import type { ${controller.name} as ${serverAlias} } from '${importSpecifier}';`,
+		...helperImports.length > 0 ? [`import type { ${helperImports.join(", ")} } from 'nestbridge';`] : [],
+		"",
+		"/**",
+		" * Generated by NestBridge — client-facing methods only.",
+		` * @see {@link ${sourceFileSpecifier}} for the real controller implementation.`,
+		" */",
+		...wrappedResultTypeAliasLines,
+		`export declare class ${controller.name} {`,
+		classBody,
+		"}",
+		""
+	].join("\n");
+};
+var ERROR_BODY_TYPE_NAME = "NestBridgeErrorBody";
+var generateErrorBodyDeclaration = (errorBodyTypeSource) => [
+	"/**",
+	" * Generated by NestBridge — inferred shape of the global exception filter's response body.",
+	" */",
+	`export type ${ERROR_BODY_TYPE_NAME} = ${errorBodyTypeSource};`,
+	""
+].join("\n");
+var formatDiagnostic = (diagnostic) => {
+	const subject = diagnostic.memberName.length > 0 ? `${diagnostic.controllerName}.${diagnostic.memberName}` : diagnostic.controllerName;
+	const lines = [
+		`[NestBridge] ${diagnostic.title}`,
+		"",
+		subject,
+		"",
+		diagnostic.detail
+	];
+	if (diagnostic.found !== void 0) lines.push("", "Found:", diagnostic.found);
+	if (diagnostic.expected !== void 0) lines.push("", "Expected:", diagnostic.expected);
+	lines.push("", `${diagnostic.filePath}:${diagnostic.line}:${diagnostic.column}`);
+	return lines.join("\n");
+};
+var generateConfigModule = (options) => {
+	if (options.baseURL === void 0) return "";
+	return [
+		"import { setNestBridgeBaseURL } from 'nestbridge';",
+		"",
+		`setNestBridgeBaseURL(${JSON.stringify(options.baseURL)});`,
+		""
+	].join("\n");
+};
+/**
+* Must not contain a colon: webpack treats any `letter+:` prefix as a URL
+* scheme and routes the request past its filesystem resolver entirely,
+* bypassing the resolveId hook this virtual module relies on.
+*/
+var CONFIG_VIRTUAL_MODULE_ID = "virtual-nestbridge-config";
+var RESOLVED_CONFIG_VIRTUAL_MODULE_ID = `\0${CONFIG_VIRTUAL_MODULE_ID}`;
+var mergeNamedParametersExpression = (parameters) => {
+	if (parameters.length === 0) return;
+	const whole = parameters.find((parameter) => parameter.name === void 0);
+	const named = parameters.filter((parameter) => parameter.name !== void 0);
+	const namedEntries = named.map((parameter) => `${JSON.stringify(parameter.name)}: ${parameter.parameterName}`);
+	if (whole === void 0) return `{ ${namedEntries.join(", ")} }`;
+	if (named.length === 0) return whole.parameterName;
+	return `{ ...${whole.parameterName}, ${namedEntries.join(", ")} }`;
+};
+var generateBodyExpression = (parameters) => mergeNamedParametersExpression(parameters.filter((parameter) => parameter.kind === "body"));
+var generateHeadersExpression = (parameters) => {
+	const headerParameters = parameters.filter((parameter) => parameter.kind === "header");
+	if (headerParameters.length === 0) return;
+	return `{ ${headerParameters.map((parameter) => `${JSON.stringify(parameter.name)}: ${parameter.parameterName}`).join(", ")} }`;
+};
+var generateParameterList = (parameters) => [...parameters].sort((a, b) => a.index - b.index).map((parameter) => parameter.parameterName).join(", ");
+var PARAM_TOKEN_PATTERN = /:([A-Za-z0-9_]+)/;
+var generatePathExpression = (method) => {
+	const paramParameters = method.parameters.filter((parameter) => parameter.kind === "param");
+	const parts = method.path.split(PARAM_TOKEN_PATTERN);
+	const expressionParts = [];
+	parts.forEach((part, index) => {
+		if (!(index % 2 === 1)) {
+			if (part.length > 0) expressionParts.push(JSON.stringify(part));
+			return;
+		}
+		const match = paramParameters.find((parameter) => parameter.name === part);
+		expressionParts.push(match !== void 0 ? `encodeURIComponent(${match.parameterName})` : JSON.stringify(`:${part}`));
+	});
+	return expressionParts.length > 0 ? expressionParts.join(" + ") : "''";
+};
+var generateQueryExpression = (parameters) => mergeNamedParametersExpression(parameters.filter((parameter) => parameter.kind === "query"));
+var generateMethod$1 = (method) => {
+	const requestProperties = [`method: ${JSON.stringify(method.httpMethod)}`, `path: ${generatePathExpression(method)}`];
+	const queryExpression = generateQueryExpression(method.parameters);
+	if (queryExpression !== void 0) requestProperties.push(`query: ${queryExpression}`);
+	const bodyExpression = generateBodyExpression(method.parameters);
+	if (bodyExpression !== void 0) requestProperties.push(`body: ${bodyExpression}`);
+	const headersExpression = generateHeadersExpression(method.parameters);
+	if (headersExpression !== void 0) requestProperties.push(`headers: ${headersExpression}`);
+	if (method.responseKind === "stream") requestProperties.push(`responseType: "blob"`);
+	return [
+		`  ${method.name}(${generateParameterList(method.parameters)}) {`,
+		"    return request({",
+		...requestProperties.map((property) => `      ${property},`),
+		"    });",
+		"  }"
+	].join("\n");
+};
+var generateControllerModule = (controller) => {
+	const methods = controller.methods.map(generateMethod$1).join("\n\n");
+	return [
+		`import '${CONFIG_VIRTUAL_MODULE_ID}';`,
+		"import { request } from 'nestbridge';",
+		"",
+		`export class ${controller.name} {`,
+		"  constructor() {}",
+		"",
+		methods,
+		"}",
+		""
+	].join("\n");
+};
+var capitalize = (value) => `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+var renderSelectionSet = (fields) => {
+	return `{ ${fields.map((field) => field.children === void 0 ? field.name : `${field.name} ${renderSelectionSet(field.children)}`).join(" ")} }`;
+};
+var generateGraphqlDocument = (method) => {
+	const variableDeclarations = method.arguments.map((argument) => `$${argument.name}: ${argument.graphqlType}`).join(", ");
+	const fieldArguments = method.arguments.map((argument) => `${argument.name}: $${argument.name}`).join(", ");
+	const variablesClause = variableDeclarations.length > 0 ? `(${variableDeclarations})` : "";
+	const fieldArgumentsClause = fieldArguments.length > 0 ? `(${fieldArguments})` : "";
+	const fieldSelection = method.selection.length > 0 ? ` ${renderSelectionSet(method.selection)}` : "";
+	return `${method.operationKind} ${capitalize(method.name)}${variablesClause} { ${method.operationName}${fieldArgumentsClause}${fieldSelection} }`;
+};
+var generateResolverArgumentList = (resolverArguments) => [...resolverArguments].sort((a, b) => a.index - b.index).map((argument) => argument.parameterName).join(", ");
+var generateVariablesExpression = (resolverArguments) => {
+	if (resolverArguments.length === 0) return;
+	return `{ ${resolverArguments.map((argument) => `${JSON.stringify(argument.name)}: ${argument.parameterName}`).join(", ")} }`;
+};
+var generateMethod = (method) => {
+	const requestProperties = [`document: ${JSON.stringify(generateGraphqlDocument(method))}`];
+	const variablesExpression = generateVariablesExpression(method.arguments);
+	if (variablesExpression !== void 0) requestProperties.push(`variables: ${variablesExpression}`);
+	return [
+		`  async ${method.name}(${generateResolverArgumentList(method.arguments)}) {`,
+		"    const result = await graphqlRequest({",
+		...requestProperties.map((property) => `      ${property},`),
+		"    });",
+		"",
+		`    return result.${method.operationName};`,
+		"  }"
+	].join("\n");
+};
+var generateResolverModule = (resolver) => {
+	const methods = resolver.methods.map(generateMethod).join("\n\n");
+	return [
+		`import '${CONFIG_VIRTUAL_MODULE_ID}';`,
+		"import { graphqlRequest } from 'nestbridge';",
+		"",
+		`export class ${resolver.name} {`,
+		"  constructor() {}",
+		"",
+		methods,
+		"}",
+		""
+	].join("\n");
+};
+var stripLeadingParentSegments = (relativePath) => {
+	const segments = relativePath.split(/[\\/]/);
+	const firstOwnedIndex = segments.findIndex((segment) => segment !== "..");
+	return segments.slice(firstOwnedIndex === -1 ? segments.length : firstOwnedIndex).join("/");
+};
+var mirroredDeclarationPath = (root, outputDir, controllerFilePath) => {
+	const mirroredPath = stripLeadingParentSegments(relative(root, controllerFilePath)).replace(/\.ts$/, ".d.ts");
+	return join(root, outputDir, mirroredPath);
+};
+var writeControllerDeclarations = (controllers, root, outputDir, responseWrapper) => {
+	for (const controller of controllers) {
+		const outputFilePath = mirroredDeclarationPath(root, outputDir, controller.sourceFile);
+		mkdirSync(dirname(outputFilePath), { recursive: true });
+		writeFileSync(outputFilePath, generateControllerDeclaration(controller, outputFilePath, responseWrapper), "utf-8");
+	}
+};
+var ERROR_BODY_DECLARATION_FILE_NAME = "nestbridge-error-body.d.ts";
+var errorBodyDeclarationPath = (root, outputDir) => join(root, outputDir, ERROR_BODY_DECLARATION_FILE_NAME);
+var writeErrorBodyDeclaration = (root, outputDir, errorResponseShape) => {
+	const outputFilePath = errorBodyDeclarationPath(root, outputDir);
+	if (errorResponseShape === void 0) {
+		rmSync(outputFilePath, { force: true });
+		return;
+	}
+	mkdirSync(dirname(outputFilePath), { recursive: true });
+	writeFileSync(outputFilePath, generateErrorBodyDeclaration(errorResponseShape.errorBodyTypeSource), "utf-8");
+};
+var writeResolverDeclarations = (resolvers, root, outputDir) => {
+	for (const resolver of resolvers) {
+		const outputFilePath = mirroredDeclarationPath(root, outputDir, resolver.sourceFile);
+		mkdirSync(dirname(outputFilePath), { recursive: true });
+		writeFileSync(outputFilePath, generateControllerDeclaration(resolver, outputFilePath), "utf-8");
+	}
+};
+var discoverFiles = (patterns, root, exclude) => {
+	const matches = globSync([...patterns], {
+		cwd: root,
+		exclude
+	});
+	return [...new Set(matches.map((match) => resolve(root, match)))].sort();
+};
+var BOOTSTRAP_FILE_PATTERN = "**/main.ts";
+var discoverBootstrapFile = (root, outputDir) => {
+	const resolvedOutputDir = resolve(root, outputDir);
+	const isExcluded = (filePath) => {
+		if (filePath.split(/[\\/]/).includes("node_modules")) return true;
+		const resolvedPath = resolve(root, filePath);
+		return resolvedPath === resolvedOutputDir || resolvedPath.startsWith(`${resolvedOutputDir}${sep}`);
+	};
+	const matches = discoverFiles([BOOTSTRAP_FILE_PATTERN], root, isExcluded);
+	return matches.length === 1 ? matches[0] : void 0;
+};
+var resolveNestBridgeOptions = (options) => ({
+	controllers: Array.isArray(options.controllers) ? options.controllers : [options.controllers],
+	resolvers: options.resolvers === void 0 ? [] : Array.isArray(options.resolvers) ? options.resolvers : [options.resolvers],
+	baseURL: options.baseURL,
+	debug: options.debug ?? false,
+	outputDir: options.outputDir ?? ".nestbridge",
+	root: options.root
+});
+var isWindows = process.platform === "win32";
+var normalizePath = (filePath) => posix.normalize(isWindows ? filePath.replaceAll("\\", "/") : filePath);
+var createControllerRegistry = (patterns, root) => {
+	const controllersByFile = /* @__PURE__ */ new Map();
+	const refresh = () => {
+		controllersByFile.clear();
+		const { controllers, diagnostics } = analyzeControllers(discoverFiles(patterns, root));
+		for (const controller of controllers) controllersByFile.set(normalizePath(controller.sourceFile), controller);
+		return {
+			controllers,
+			diagnostics
+		};
+	};
+	return {
+		refresh,
+		get: (filePath) => controllersByFile.get(filePath),
+		has: (filePath) => controllersByFile.has(filePath),
+		all: () => [...controllersByFile.values()]
+	};
+};
+var createResolverRegistry = (patterns, root) => {
+	const resolversByFile = /* @__PURE__ */ new Map();
+	const refresh = () => {
+		resolversByFile.clear();
+		const { resolvers, diagnostics } = analyzeResolvers(discoverFiles(patterns, root));
+		for (const resolver of resolvers) resolversByFile.set(normalizePath(resolver.sourceFile), resolver);
+		return {
+			resolvers,
+			diagnostics
+		};
+	};
+	return {
+		refresh,
+		get: (filePath) => resolversByFile.get(filePath),
+		has: (filePath) => resolversByFile.has(filePath),
+		all: () => [...resolversByFile.values()]
+	};
+};
+var reportDiagnostics = (diagnostics, watchMode) => {
+	for (const diagnostic of diagnostics) {
+		const message = formatDiagnostic(diagnostic);
+		if (watchMode === false) throw new Error(message);
+		console.warn(message);
+	}
+};
+var nestBridgeUnplugin = createUnplugin((options, meta) => {
+	const resolvedOptions = resolveNestBridgeOptions(options);
+	let root = resolvedOptions.root ?? process.cwd();
+	let controllerRegistry;
+	let resolverRegistry;
+	let bootstrapFilePath;
+	const log = (message) => {
+		if (resolvedOptions.debug) console.log(`[nestbridge] ${message}`);
+	};
+	const runAnalysis = () => {
+		const { controllers, diagnostics: controllerDiagnostics } = controllerRegistry.refresh();
+		const { resolvers, diagnostics: resolverDiagnostics } = resolverRegistry.refresh();
+		reportDiagnostics([...controllerDiagnostics, ...resolverDiagnostics], meta.watchMode);
+		const discoveredBootstrapFile = discoverBootstrapFile(root, resolvedOptions.outputDir);
+		bootstrapFilePath = discoveredBootstrapFile !== void 0 ? normalizePath(discoveredBootstrapFile) : void 0;
+		const responseWrapper = discoveredBootstrapFile !== void 0 ? detectResponseWrapper(discoveredBootstrapFile) : void 0;
+		const errorResponseShape = discoveredBootstrapFile !== void 0 ? detectErrorResponseShape(discoveredBootstrapFile) : void 0;
+		writeControllerDeclarations(controllers, root, resolvedOptions.outputDir, responseWrapper);
+		writeResolverDeclarations(resolvers, root, resolvedOptions.outputDir);
+		writeErrorBodyDeclaration(root, resolvedOptions.outputDir, errorResponseShape);
+		log(`analyzed ${controllers.length} controller(s), ${resolvers.length} resolver(s), ${controllerDiagnostics.length + resolverDiagnostics.length} diagnostic(s)`);
+	};
+	return {
+		name: "nestbridge",
+		enforce: "pre",
+		buildStart() {
+			controllerRegistry = createControllerRegistry(resolvedOptions.controllers, root);
+			resolverRegistry = createResolverRegistry(resolvedOptions.resolvers, root);
+			runAnalysis();
+		},
+		resolveId(source) {
+			if (source === "virtual-nestbridge-config") return RESOLVED_CONFIG_VIRTUAL_MODULE_ID;
+			return null;
+		},
+		load(id) {
+			if (id === RESOLVED_CONFIG_VIRTUAL_MODULE_ID) return generateConfigModule(resolvedOptions);
+			return null;
+		},
+		transform(_code, id) {
+			const absolutePath = normalizePath(id);
+			const controller = controllerRegistry.get(absolutePath);
+			if (controller !== void 0) return generateControllerModule(controller);
+			const resolver = resolverRegistry.get(absolutePath);
+			if (resolver !== void 0) return generateResolverModule(resolver);
+			return null;
+		},
+		watchChange(id) {
+			const changedFile = normalizePath(id);
+			const wasTracked = controllerRegistry.has(changedFile) || resolverRegistry.has(changedFile) || changedFile === bootstrapFilePath;
+			const discoveredBootstrapFile = discoverBootstrapFile(root, resolvedOptions.outputDir);
+			const isTrackedNow = discoverFiles(resolvedOptions.controllers, root).map(normalizePath).includes(changedFile) || discoverFiles(resolvedOptions.resolvers, root).map(normalizePath).includes(changedFile) || discoveredBootstrapFile !== void 0 && normalizePath(discoveredBootstrapFile) === changedFile;
+			if (!wasTracked && !isTrackedNow) return;
+			runAnalysis();
+			log(`nestbridge source changed: ${changedFile}`);
+		},
+		vite: { configResolved(config) {
+			if (resolvedOptions.root === void 0) root = config.root;
+		} }
+	};
+});
+//#endregion
+//#region src/version.ts
+var VERSION = "2.1.0";
+//#endregion
+//#region src/main.ts
+var nestBridge = nestBridgeUnplugin.webpack;
+//#endregion
+export { VERSION, nestBridge };
+
+//# sourceMappingURL=nestbridge.webpack.js.map