@nestbridge/webpack 2.0.1 → 2.0.3

package/build/nestbridge.webpack.js

@@ -1,1116 +0,0 @@
-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.1";
-//#endregion
-//#region src/main.ts
-var nestBridge = nestBridgeUnplugin.webpack;
-//#endregion
-export { VERSION, nestBridge };
-
-//# sourceMappingURL=nestbridge.webpack.js.map