nitro-graphql 2.0.0-beta.31 → 2.0.0-beta.33

package/dist/rollup.d.mts

@@ -1,12 +1,6 @@
 import { Nitro } from "nitro/types";
 
 //#region src/rollup.d.ts
-declare function rollupConfig(app: Nitro): Promise<void>;
-declare function virtualSchemas(app: Nitro): void;
-declare function virtualResolvers(app: Nitro): void;
-declare function virtualDirectives(app: Nitro): void;
-declare function getGraphQLConfig(app: Nitro): void;
-declare function virtualModuleConfig(app: Nitro): void;
-declare function virtualDebugInfo(app: Nitro): void;
+declare function rollupConfig(nitro: Nitro): Promise<void>;
 //#endregion
-export { getGraphQLConfig, rollupConfig, virtualDebugInfo, virtualDirectives, virtualModuleConfig, virtualResolvers, virtualSchemas };
+export { rollupConfig };

package/dist/rollup.mjs

@@ -1,29 +1,33 @@
-import { getImportId, scanGraphql } from "./utils/index.mjs";
-import { clientTypeGeneration, serverTypeGeneration } from "./utils/type-generation.mjs";
+import { generateServerTypes } from "./codegen/server-types.mjs";
+import { generateClientTypes } from "./codegen/index.mjs";
+import { scanGraphql } from "./utils/scanning/schemas.mjs";
+import { virtualGraphQLConfig, virtualModuleConfig } from "./virtual/generators/config.mjs";
+import { virtualDebugInfo } from "./virtual/generators/debug.mjs";
+import { virtualDirectives } from "./virtual/generators/directives.mjs";
+import { virtualResolvers } from "./virtual/generators/resolvers.mjs";
+import { virtualSchemas } from "./virtual/generators/schemas.mjs";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
-import { resolve } from "pathe";
 import { parse } from "graphql";
-import { genImport } from "knitwork";
 
 //#region src/rollup.ts
-async function rollupConfig(app) {
-	virtualSchemas(app);
-	virtualResolvers(app);
-	virtualDirectives(app);
-	getGraphQLConfig(app);
-	virtualModuleConfig(app);
-	virtualDebugInfo(app);
-	app.hooks.hook("rollup:before", (nitro, rollupConfig$1) => {
+async function rollupConfig(nitro) {
+	virtualSchemas(nitro);
+	virtualResolvers(nitro);
+	virtualDirectives(nitro);
+	virtualGraphQLConfig(nitro);
+	virtualModuleConfig(nitro);
+	virtualDebugInfo(nitro);
+	nitro.hooks.hook("rollup:before", (_, rollupConfig$1) => {
 		rollupConfig$1.plugins = rollupConfig$1.plugins || [];
-		const { include = /\.(?:graphql|gql)$/i, exclude, validate = false } = app.options.graphql?.loader || {};
+		const { include = /\.(?:graphql|gql)$/i, exclude, validate = false } = nitro.options.graphql?.loader || {};
 		if (Array.isArray(rollupConfig$1.plugins)) {
 			rollupConfig$1.plugins.push({
 				name: "nitro-graphql:virtual",
 				resolveId: {
 					order: "pre",
 					filter: { id: /^#nitro-graphql\// },
-					async handler(id, parent, options) {
+					async handler(id, parent, _options) {
 						if (id.startsWith("#nitro-graphql/")) return `\0virtual:${id}`;
 						if (parent?.startsWith("\0virtual:#nitro-graphql")) {
 							const runtimeDir = fileURLToPath(new URL("routes", import.meta.url));
@@ -41,7 +45,7 @@ async function rollupConfig(app) {
 					async handler(id) {
 						if (id.startsWith("\0virtual:#nitro-graphql/")) {
 							const moduleName = id.slice(9);
-							const generator = app.options.virtual?.[moduleName];
+							const generator = nitro.options.virtual?.[moduleName];
 							if (typeof generator === "function") try {
 								return {
 									code: await generator(),
@@ -81,7 +85,7 @@ async function rollupConfig(app) {
 					}
 				}
 			});
-			if (app.options.dev) rollupConfig$1.plugins.push({
+			if (nitro.options.dev) rollupConfig$1.plugins.push({
 				name: "nitro-graphql-watcher",
 				buildStart: {
 					order: "pre",
@@ -93,190 +97,11 @@ async function rollupConfig(app) {
 			});
 		}
 	});
-	app.hooks.hook("dev:reload", async () => {
-		await serverTypeGeneration(app, { silent: true });
-		await clientTypeGeneration(app, { silent: true });
+	nitro.hooks.hook("dev:reload", async () => {
+		await generateServerTypes(nitro, { silent: true });
+		await generateClientTypes(nitro, { silent: true });
 	});
 }
-function virtualSchemas(app) {
-	const getSchemas = () => [...app.scanSchemas, ...app.options.graphql?.typedefs ?? []];
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-graphql/server-schemas"] = () => {
-		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)} }`);
-			return `
-${importStatements.join("\n")}
-
-export const schemas = [
-${schemaArray.join(",\n")}
-];
-    `;
-		} catch (error) {
-			app.logger.error("[nitro-graphql] Failed to generate virtual schema module:", error);
-			return "export const schemas = []";
-		}
-	};
-}
-function virtualResolvers(app) {
-	const getResolvers = () => [...app.scanResolvers];
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-graphql/server-resolvers"] = () => {
-		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");
-			return [
-				...importsContent,
-				"",
-				"export const resolvers = [",
-				data,
-				"]",
-				""
-			].join("\n");
-		} catch (error) {
-			app.logger.error("[nitro-graphql] Failed to generate virtual resolver module:", error);
-			return "export const resolvers = []";
-		}
-	};
-}
-function virtualDirectives(app) {
-	const getDirectives = () => app.scanDirectives || [];
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-graphql/server-directives"] = () => {
-		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");
-			return [
-				...importsContent,
-				"",
-				"export const directives = [",
-				data,
-				"]",
-				""
-			].join("\n");
-		} catch (error) {
-			app.logger.error("[nitro-graphql] Failed to generate virtual directive module:", error);
-			return "export const directives = []";
-		}
-	};
-}
-function getGraphQLConfig(app) {
-	const configPath = resolve(app.graphql.serverDir, "config.ts");
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-graphql/graphql-config"] = () => {
-		return `import config from '${configPath}'
-const importedConfig = config
-export { importedConfig }
-`;
-	};
-}
-function virtualModuleConfig(app) {
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-graphql/module-config"] = () => {
-		const moduleConfig = app.options.graphql || {};
-		return `export const moduleConfig = ${JSON.stringify(moduleConfig, null, 2)};`;
-	};
-}
-function virtualDebugInfo(app) {
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-graphql/debug-info"] = () => {
-		const virtualModuleCodes = {};
-		try {
-			const schemasGenerator = app.options.virtual["#nitro-graphql/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-graphql/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-graphql/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-graphql/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-graphql/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 { getGraphQLConfig, rollupConfig, virtualDebugInfo, virtualDirectives, virtualModuleConfig, virtualResolvers, virtualSchemas };
+export { rollupConfig };

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

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

package/dist/routes/apollo-server.mjs

@@ -1,7 +1,5 @@
+import { createMergedSchema } from "../utils/schema-builder.mjs";
 import defu from "defu";
-import { consola as consola$1 } from "consola";
-import { parse } from "graphql";
-import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
 import { importedConfig } from "#nitro-graphql/graphql-config";
 import { moduleConfig } from "#nitro-graphql/module-config";
 import { directives } from "#nitro-graphql/server-directives";
@@ -9,63 +7,21 @@ import { resolvers } from "#nitro-graphql/server-resolvers";
 import { schemas } from "#nitro-graphql/server-schemas";
 import { ApolloServer } from "@apollo/server";
 import { ApolloServerPluginLandingPageLocalDefault } from "@apollo/server/plugin/landingPage/default";
-import { makeExecutableSchema } from "@graphql-tools/schema";
 import { startServerAndCreateH3Handler } from "nitro-graphql/utils/apollo";
 import { defineEventHandler } from "nitro/h3";
 
 //#region src/routes/apollo-server.ts
-let buildSubgraphSchema = null;
-async function loadFederationSupport() {
-	if (buildSubgraphSchema !== null) return buildSubgraphSchema;
-	try {
-		buildSubgraphSchema = (await import("@apollo/subgraph")).buildSubgraphSchema;
-	} catch {
-		buildSubgraphSchema = false;
-	}
-	return buildSubgraphSchema;
-}
-async function createMergedSchema() {
-	try {
-		const typeDefs = mergeTypeDefs([schemas.map((schema$1) => schema$1.def).join("\n\n")], {
-			throwOnConflict: true,
-			commentDescriptions: true,
-			sort: true
-		});
-		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
-		const federationEnabled = moduleConfig.federation?.enabled;
-		let schema;
-		if (federationEnabled) {
-			const buildSubgraph = await loadFederationSupport();
-			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,
-					resolvers: mergedResolvers
-				});
-			}
-		} else schema = makeExecutableSchema({
-			typeDefs,
-			resolvers: mergedResolvers
-		});
-		if (directives && directives.length > 0) {
-			for (const { directive } of directives) if (directive.transformer) schema = directive.transformer(schema);
-		}
-		return schema;
-	} catch (error) {
-		consola$1.error("Schema merge error:", error);
-		throw error;
-	}
-}
 let apolloServer = null;
 let serverStarted = false;
 async function createApolloServer() {
 	if (!apolloServer) {
 		apolloServer = new ApolloServer(defu({
-			schema: await createMergedSchema(),
+			schema: await createMergedSchema({
+				schemas,
+				resolvers,
+				directives,
+				moduleConfig
+			}),
 			introspection: true,
 			plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })]
 		}, importedConfig));

package/dist/routes/debug-template.d.mts

@@ -0,0 +1,15 @@
+//#region src/routes/debug-template.d.ts
+/**
+ * Debug dashboard HTML template
+ * Extracted from debug.ts to reduce file complexity
+ */
+/**
+ * Escape HTML special characters
+ */
+declare function escapeHtml(text: string): string;
+/**
+ * Generate the HTML dashboard for the debug endpoint
+ */
+declare function generateHtmlDashboard(debugInfo: any): string;
+//#endregion
+export { escapeHtml, generateHtmlDashboard };