nitro-graphql 1.4.3 → 1.5.0

package/dist/rollup.js

@@ -12,6 +12,7 @@ async function rollupConfig(app) {
 	virtualDirectives(app);
 	getGraphQLConfig(app);
 	virtualModuleConfig(app);
+	virtualDebugInfo(app);
 	app.hooks.hook("rollup:before", (nitro, rollupConfig$1) => {
 		rollupConfig$1.plugins = rollupConfig$1.plugins || [];
 		const { include = /\.(graphql|gql)$/i, exclude, validate = false } = app.options.graphql?.loader || {};
@@ -49,66 +50,128 @@ async function rollupConfig(app) {
 }
 function virtualSchemas(app) {
 	const getSchemas = () => {
-		const schemas = [...app.scanSchemas, ...app.options.graphql?.typedefs ?? []];
-		return schemas;
+		return [...app.scanSchemas, ...app.options.graphql?.typedefs ?? []];
 	};
 	app.options.virtual ??= {};
 	app.options.virtual["#nitro-internal-virtual/server-schemas"] = () => {
-		const imports = getSchemas();
-		const code = `
-${imports.map((handler) => `import ${getImportId(handler)} from '${handler}';`).join("\n")}
+		try {
+			const imports = getSchemas();
+			if (imports.length === 0) {
+				if (app.options.dev) app.logger.warn("[nitro-graphql] No schemas found. Virtual module will export empty array.");
+				return "export const schemas = []";
+			}
+			const importStatements = imports.map((handler) => `import ${getImportId(handler)} from '${handler}';`);
+			const schemaArray = imports.map((h) => `{ def: ${getImportId(h)} }`);
+			const code = `
+${importStatements.join("\n")}
 
 export const schemas = [
-${imports.map((h) => `{ def: ${getImportId(h)} }`).join(",\n")}
+${schemaArray.join(",\n")}
 ];
     `;
-		return code;
+			if (app.options.dev) app.logger.success(`[nitro-graphql] Generated virtual schema module: ${imports.length} schema(s)`);
+			return code;
+		} catch (error) {
+			app.logger.error("[nitro-graphql] Failed to generate virtual schema module:", error);
+			return "export const schemas = []";
+		}
 	};
 }
 function virtualResolvers(app) {
 	const getResolvers = () => {
-		const resolvers = [...app.scanResolvers];
-		return resolvers;
+		return [...app.scanResolvers];
 	};
 	app.options.virtual ??= {};
 	app.options.virtual["#nitro-internal-virtual/server-resolvers"] = () => {
-		const imports = getResolvers();
-		const importsContent = [...imports.map(({ specifier, imports: imports$1, options }) => {
-			return genImport(specifier, imports$1, options);
-		})];
-		const data = imports.map(({ imports: imports$1 }) => imports$1.map((i) => `{ resolver: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n");
-		const content = [
-			"export const resolvers = [",
-			data,
-			"]",
-			""
-		];
-		content.unshift(...importsContent);
-		const code = content.join("\n");
-		return code;
+		try {
+			const imports = getResolvers();
+			if (imports.length === 0) {
+				if (app.options.dev) app.logger.warn("[nitro-graphql] No resolvers found. Virtual module will export empty array.");
+				return "export const resolvers = []";
+			}
+			const importsContent = [];
+			const invalidImports = [];
+			for (const { specifier, imports: importList, options } of imports) try {
+				if (!importList || importList.length === 0) {
+					invalidImports.push(`${specifier}: No exports found`);
+					continue;
+				}
+				const importCode = genImport(specifier, importList, options);
+				importsContent.push(importCode);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				invalidImports.push(`${specifier}: ${message}`);
+				if (app.options.dev) app.logger.error(`[nitro-graphql] Failed to generate import for ${specifier}:`, error);
+			}
+			if (invalidImports.length > 0 && app.options.dev) {
+				app.logger.warn("[nitro-graphql] Some resolver imports could not be generated:");
+				for (const msg of invalidImports) app.logger.warn(`  - ${msg}`);
+			}
+			const data = imports.map(({ imports: importList }) => importList.map((i) => `{ resolver: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n");
+			const code = [
+				...importsContent,
+				"",
+				"export const resolvers = [",
+				data,
+				"]",
+				""
+			].join("\n");
+			if (app.options.dev) {
+				const totalExports = imports.reduce((sum, r) => sum + r.imports.length, 0);
+				app.logger.success(`[nitro-graphql] Generated virtual resolver module: ${totalExports} export(s) from ${imports.length} file(s)`);
+			}
+			return code;
+		} catch (error) {
+			app.logger.error("[nitro-graphql] Failed to generate virtual resolver module:", error);
+			return "export const resolvers = []";
+		}
 	};
 }
 function virtualDirectives(app) {
 	const getDirectives = () => {
-		const directives = [...app.scanDirectives || []];
-		return directives;
+		return [...app.scanDirectives || []];
 	};
 	app.options.virtual ??= {};
 	app.options.virtual["#nitro-internal-virtual/server-directives"] = () => {
-		const imports = getDirectives();
-		const importsContent = [...imports.map(({ specifier, imports: imports$1, options }) => {
-			return genImport(specifier, imports$1, options);
-		})];
-		const data = imports.map(({ imports: imports$1 }) => imports$1.map((i) => `{ directive: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n");
-		const content = [
-			"export const directives = [",
-			data,
-			"]",
-			""
-		];
-		content.unshift(...importsContent);
-		const code = content.join("\n");
-		return code;
+		try {
+			const imports = getDirectives();
+			if (imports.length === 0) return "export const directives = []";
+			const importsContent = [];
+			const invalidImports = [];
+			for (const { specifier, imports: importList, options } of imports) try {
+				if (!importList || importList.length === 0) {
+					invalidImports.push(`${specifier}: No exports found`);
+					continue;
+				}
+				const importCode = genImport(specifier, importList, options);
+				importsContent.push(importCode);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				invalidImports.push(`${specifier}: ${message}`);
+				if (app.options.dev) app.logger.error(`[nitro-graphql] Failed to generate import for directive ${specifier}:`, error);
+			}
+			if (invalidImports.length > 0 && app.options.dev) {
+				app.logger.warn("[nitro-graphql] Some directive imports could not be generated:");
+				for (const msg of invalidImports) app.logger.warn(`  - ${msg}`);
+			}
+			const data = imports.map(({ imports: importList }) => importList.map((i) => `{ directive: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n");
+			const code = [
+				...importsContent,
+				"",
+				"export const directives = [",
+				data,
+				"]",
+				""
+			].join("\n");
+			if (app.options.dev) {
+				const totalExports = imports.reduce((sum, d) => sum + d.imports.length, 0);
+				app.logger.success(`[nitro-graphql] Generated virtual directive module: ${totalExports} directive(s) from ${imports.length} file(s)`);
+			}
+			return code;
+		} catch (error) {
+			app.logger.error("[nitro-graphql] Failed to generate virtual directive module:", error);
+			return "export const directives = []";
+		}
 	};
 }
 function getGraphQLConfig(app) {
@@ -128,6 +191,60 @@ function virtualModuleConfig(app) {
 		return `export const moduleConfig = ${JSON.stringify(moduleConfig, null, 2)};`;
 	};
 }
+function virtualDebugInfo(app) {
+	app.options.virtual ??= {};
+	app.options.virtual["#nitro-internal-virtual/debug-info"] = () => {
+		const virtualModuleCodes = {};
+		try {
+			const schemasGenerator = app.options.virtual["#nitro-internal-virtual/server-schemas"];
+			if (schemasGenerator && typeof schemasGenerator === "function") virtualModuleCodes["server-schemas"] = schemasGenerator();
+		} catch (error) {
+			virtualModuleCodes["server-schemas"] = `// Error generating: ${error instanceof Error ? error.message : String(error)}`;
+		}
+		try {
+			const resolversGenerator = app.options.virtual["#nitro-internal-virtual/server-resolvers"];
+			if (resolversGenerator && typeof resolversGenerator === "function") virtualModuleCodes["server-resolvers"] = resolversGenerator();
+		} catch (error) {
+			virtualModuleCodes["server-resolvers"] = `// Error generating: ${error instanceof Error ? error.message : String(error)}`;
+		}
+		try {
+			const directivesGenerator = app.options.virtual["#nitro-internal-virtual/server-directives"];
+			if (directivesGenerator && typeof directivesGenerator === "function") virtualModuleCodes["server-directives"] = directivesGenerator();
+		} catch (error) {
+			virtualModuleCodes["server-directives"] = `// Error generating: ${error instanceof Error ? error.message : String(error)}`;
+		}
+		try {
+			const moduleConfigGenerator = app.options.virtual["#nitro-internal-virtual/module-config"];
+			if (moduleConfigGenerator && typeof moduleConfigGenerator === "function") virtualModuleCodes["module-config"] = moduleConfigGenerator();
+		} catch (error) {
+			virtualModuleCodes["module-config"] = `// Error generating: ${error instanceof Error ? error.message : String(error)}`;
+		}
+		try {
+			const graphqlConfigGenerator = app.options.virtual["#nitro-internal-virtual/graphql-config"];
+			if (graphqlConfigGenerator && typeof graphqlConfigGenerator === "function") virtualModuleCodes["graphql-config"] = graphqlConfigGenerator();
+		} catch (error) {
+			virtualModuleCodes["graphql-config"] = `// Error generating: ${error instanceof Error ? error.message : String(error)}`;
+		}
+		const debugInfo = {
+			isDev: app.options.dev,
+			framework: app.options.framework.name,
+			graphqlFramework: app.options.graphql?.framework,
+			federation: app.options.graphql?.federation,
+			scanned: {
+				schemas: app.scanSchemas?.length || 0,
+				schemaFiles: app.scanSchemas || [],
+				resolvers: app.scanResolvers?.length || 0,
+				resolverFiles: app.scanResolvers || [],
+				directives: app.scanDirectives?.length || 0,
+				directiveFiles: app.scanDirectives || [],
+				documents: app.scanDocuments?.length || 0,
+				documentFiles: app.scanDocuments || []
+			},
+			virtualModules: virtualModuleCodes
+		};
+		return `export const debugInfo = ${JSON.stringify(debugInfo, null, 2)};`;
+	};
+}
 
 //#endregion
 export { rollupConfig };

package/dist/routes/apollo-server.d.ts

@@ -1,6 +1,6 @@
-import * as h30 from "h3";
+import * as h31 from "h3";
 
 //#region src/routes/apollo-server.d.ts
-declare const _default: h30.EventHandler<h30.EventHandlerRequest, Promise<any>>;
+declare const _default: h31.EventHandler<h31.EventHandlerRequest, Promise<any>>;
 //#endregion
 export { _default as default };

package/dist/routes/apollo-server.js

@@ -18,8 +18,7 @@ let buildSubgraphSchema = null;
 async function loadFederationSupport() {
 	if (buildSubgraphSchema !== null) return buildSubgraphSchema;
 	try {
-		const apolloSubgraph = await import("@apollo/subgraph");
-		buildSubgraphSchema = apolloSubgraph.buildSubgraphSchema;
+		buildSubgraphSchema = (await import("@apollo/subgraph")).buildSubgraphSchema;
 	} catch {
 		buildSubgraphSchema = false;
 	}
@@ -27,8 +26,7 @@ async function loadFederationSupport() {
 }
 async function createMergedSchema() {
 	try {
-		const mergedSchemas = schemas.map((schema$1) => schema$1.def).join("\n\n");
-		const typeDefs = mergeTypeDefs([mergedSchemas], {
+		const typeDefs = mergeTypeDefs([schemas.map((schema$1) => schema$1.def).join("\n\n")], {
 			throwOnConflict: true,
 			commentDescriptions: true,
 			sort: true
@@ -38,13 +36,11 @@ async function createMergedSchema() {
 		let schema;
 		if (federationEnabled) {
 			const buildSubgraph = await loadFederationSupport();
-			if (buildSubgraph) {
-				const typeDefsDoc = typeof typeDefs === "string" ? parse(typeDefs) : typeDefs;
-				schema = buildSubgraph({
-					typeDefs: typeDefsDoc,
-					resolvers: mergedResolvers
-				});
-			} else {
+			if (buildSubgraph) schema = buildSubgraph({
+				typeDefs: typeof typeDefs === "string" ? parse(typeDefs) : typeDefs,
+				resolvers: mergedResolvers
+			});
+			else {
 				console.warn("Federation enabled but @apollo/subgraph not available, falling back to regular schema");
 				schema = makeExecutableSchema({
 					typeDefs,
@@ -68,9 +64,8 @@ let apolloServer = null;
 let serverStarted = false;
 async function createApolloServer() {
 	if (!apolloServer) {
-		const schema = await createMergedSchema();
 		apolloServer = new ApolloServer(defu({
-			schema,
+			schema: await createMergedSchema(),
 			introspection: true,
 			plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })]
 		}, importedConfig));
@@ -84,12 +79,10 @@ async function createApolloServer() {
 let serverPromise = null;
 var apollo_server_default = defineEventHandler(async (event) => {
 	if (!serverPromise) serverPromise = createApolloServer();
-	const server = await serverPromise;
-	const h3Handler = startServerAndCreateH3Handler(server, {
+	return startServerAndCreateH3Handler(await serverPromise, {
 		context: async () => ({ event }),
 		serverAlreadyStarted: true
-	});
-	return h3Handler(event);
+	})(event);
 });
 
 //#endregion

package/dist/routes/debug.d.ts

@@ -0,0 +1,61 @@
+import * as h33 from "h3";
+
+//#region src/routes/debug.d.ts
+
+/**
+ * Debug endpoint for inspecting virtual modules and GraphQL setup
+ * Only available in development mode
+ *
+ * Routes:
+ * - /_nitro/graphql/debug - HTML dashboard
+ * - /_nitro/graphql/debug?format=json - JSON API
+ */
+declare const _default: h33.EventHandler<h33.EventHandlerRequest, Promise<string | {
+  timestamp: string;
+  environment: {
+    dev: any;
+    framework: any;
+  };
+  graphql: {
+    framework: any;
+    federation: any;
+  };
+  scanned: {
+    schemas: any;
+    schemaFiles: any;
+    resolvers: any;
+    resolverFiles: any;
+    directives: any;
+    directiveFiles: any;
+    documents: any;
+    documentFiles: any;
+  };
+  runtime: {
+    loadedResolvers: number;
+    loadedSchemas: number;
+    loadedDirectives: any;
+  };
+  virtualModules: any;
+  virtualModuleSamples: {
+    'server-resolvers': {
+      resolverCount: number;
+      sample: {
+        hasResolver: boolean;
+        resolverKeys: string[];
+      }[];
+    };
+    'server-schemas': {
+      schemaCount: number;
+      sample: {
+        defLength: number;
+        defPreview: string;
+      }[];
+    };
+    'server-directives': {
+      directiveCount: any;
+    };
+    'module-config': any;
+  };
+}>>;
+//#endregion
+export { _default as default };