@nestbridge/webpack 2.0.2 → 2.0.4

package/build/nestbridge.webpack.js

@@ -0,0 +1,1116 @@
+import { SyntaxKind, isArrayLiteralExpression, isArrayTypeNode, isArrowFunction, isBlock, isCallExpression, isClassDeclaration, isDecorator, isExportDeclaration, isFunctionExpression, isIdentifier, isImportDeclaration, isMethodDeclaration, isNamedExports, isNamedImports, isObjectLiteralExpression, isPropertyAssignment, isPropertyDeclaration, isReturnStatement, isStringLiteralLikeNode, isTypeReferenceNode, isUnionTypeNode } from "typescript/unstable/ast";
+import { API } from "typescript/unstable/sync";
+import { existsSync, globSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, extname, join, posix, relative, resolve } 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();
+	const sourceFile = sharedApi.updateSnapshot({ openFiles: [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 REMOTE_RESULT_HELPERS = {
+	json: "RemoteResult",
+	observable: "RemoteObservableResult",
+	stream: "RemoteStreamResult"
+};
+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) => {
+	const sourceFileSpecifier = importSpecifierFor(controller.sourceFile, outputFilePath);
+	const importSpecifier = stripExtension(sourceFileSpecifier);
+	const serverAlias = `__Server${controller.name}`;
+	const classBody = [
+		"  constructor();",
+		"",
+		...controller.methods.map((method) => {
+			const helperName = REMOTE_RESULT_HELPERS[method.responseKind ?? "json"];
+			return `  ${method.name}(...args: Parameters<${serverAlias}['${method.name}']>): ${helperName}<${serverAlias}['${method.name}']>;`;
+		})
+	].join("\n");
+	const usedHelperNames = new Set(controller.methods.map((method) => REMOTE_RESULT_HELPERS[method.responseKind ?? "json"]));
+	const helperImports = Array.from(usedHelperNames.size > 0 ? usedHelperNames : ["RemoteResult"]).sort();
+	return [
+		`import type { ${controller.name} as ${serverAlias} } from '${importSpecifier}';`,
+		`import type { ${helperImports.join(", ")} } from 'nestbridge';`,
+		"",
+		"/**",
+		" * Generated by NestBridge — client-facing methods only.",
+		` * @see {@link ${sourceFileSpecifier}} for the real controller implementation.`,
+		" */",
+		`export declare class ${controller.name} {`,
+		classBody,
+		"}",
+		""
+	].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) => {
+	for (const controller of controllers) {
+		const outputFilePath = mirroredDeclarationPath(root, outputDir, controller.sourceFile);
+		mkdirSync(dirname(outputFilePath), { recursive: true });
+		writeFileSync(outputFilePath, generateControllerDeclaration(controller, outputFilePath), "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) => {
+	const matches = globSync([...patterns], { cwd: root });
+	return [...new Set(matches.map((match) => resolve(root, match)))].sort();
+};
+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;
+	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);
+		writeControllerDeclarations(controllers, root, resolvedOptions.outputDir);
+		writeResolverDeclarations(resolvers, root, resolvedOptions.outputDir);
+		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);
+			const isTrackedNow = discoverFiles(resolvedOptions.controllers, root).map(normalizePath).includes(changedFile) || discoverFiles(resolvedOptions.resolvers, root).map(normalizePath).includes(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.0.4";
+//#endregion
+//#region src/main.ts
+var nestBridge = nestBridgeUnplugin.webpack;
+//#endregion
+export { VERSION, nestBridge };
+
+//# sourceMappingURL=nestbridge.webpack.js.map