nitro-graphql 2.0.0-beta.3 → 2.0.0-beta.6

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { StandardSchemaV1 } from "./types/standard-schema.js";
-import { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, FederationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions } from "./types/index.js";
-import * as nitro_types0 from "nitro/types";
+import { ClientUtilsConfig, CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, PathsConfig, ScaffoldConfig, SdkConfig, TypesConfig } from "./types/index.js";
+import * as nitropack0 from "nitropack";
 
 //#region src/index.d.ts
-declare const _default: nitro_types0.NitroModule;
+declare const _default: nitropack0.NitroModule;
 //#endregion
-export { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, FederationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, StandardSchemaV1, _default as default };
+export { ClientUtilsConfig, CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, PathsConfig, ScaffoldConfig, SdkConfig, StandardSchemaV1, TypesConfig, _default as default };

package/dist/index.js

@@ -1,8 +1,10 @@
 import { generateDirectiveSchemas } from "./utils/directive-parser.js";
 import { generateLayerIgnorePatterns, getLayerAppDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanResolvers, scanSchemas, validateExternalServices } from "./utils/index.js";
+import { writeFileIfNotExists } from "./utils/file-generator.js";
+import { getDefaultPaths, getScaffoldConfig, resolveFilePath, shouldGenerateScaffold } from "./utils/path-resolver.js";
 import { clientTypeGeneration, serverTypeGeneration } from "./utils/type-generation.js";
 import { rollupConfig } from "./rollup.js";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { watch } from "chokidar";
 import consola from "consola";
@@ -111,12 +113,53 @@ var src_default = defineNitroModule({
 		nitro.scanDirectives = directives;
 		await generateDirectiveSchemas(nitro, directives);
 		nitro.hooks.hook("dev:start", async () => {
-			nitro.scanSchemas = await scanSchemas(nitro);
-			nitro.scanResolvers = await scanResolvers(nitro);
+			const schemas = await scanSchemas(nitro);
+			nitro.scanSchemas = schemas;
+			const resolvers = await scanResolvers(nitro);
+			nitro.scanResolvers = resolvers;
 			const directives$1 = await scanDirectives(nitro);
 			nitro.scanDirectives = directives$1;
 			await generateDirectiveSchemas(nitro, directives$1);
-			nitro.scanDocuments = await scanDocs(nitro);
+			const docs = await scanDocs(nitro);
+			nitro.scanDocuments = docs;
+			if (nitro.options.dev) {
+				consola.box({
+					title: "Nitro GraphQL",
+					message: [
+						`Framework: ${nitro.options.graphql?.framework || "Not configured"}`,
+						`Schemas: ${schemas.length}`,
+						`Resolvers: ${resolvers.length}`,
+						`Directives: ${directives$1.length}`,
+						`Documents: ${docs.length}`,
+						"",
+						"Debug Dashboard: /_nitro/graphql/debug"
+					].join("\n"),
+					style: {
+						borderColor: "cyan",
+						borderStyle: "rounded"
+					}
+				});
+				if (resolvers.length > 0) {
+					const totalExports = resolvers.reduce((sum, r) => sum + r.imports.length, 0);
+					const typeCount = {
+						query: 0,
+						mutation: 0,
+						resolver: 0,
+						type: 0,
+						subscription: 0,
+						directive: 0
+					};
+					for (const resolver of resolvers) for (const imp of resolver.imports) if (imp.type in typeCount) typeCount[imp.type]++;
+					const breakdown = [];
+					if (typeCount.query > 0) breakdown.push(`${typeCount.query} query`);
+					if (typeCount.mutation > 0) breakdown.push(`${typeCount.mutation} mutation`);
+					if (typeCount.resolver > 0) breakdown.push(`${typeCount.resolver} resolver`);
+					if (typeCount.type > 0) breakdown.push(`${typeCount.type} type`);
+					if (typeCount.subscription > 0) breakdown.push(`${typeCount.subscription} subscription`);
+					if (typeCount.directive > 0) breakdown.push(`${typeCount.directive} directive`);
+					if (breakdown.length > 0) consola.success(`[nitro-graphql] ${totalExports} resolver export(s): ${breakdown.join(", ")}`);
+				} else consola.warn("[nitro-graphql] No resolvers found. Check /_nitro/graphql/debug for details.");
+			}
 		});
 		await rollupConfig(nitro);
 		await serverTypeGeneration(nitro);
@@ -146,6 +189,14 @@ var src_default = defineNitroModule({
 			handler: join(runtime, "health"),
 			method: "GET"
 		});
+		if (nitro.options.dev) {
+			nitro.options.handlers.push({
+				route: "/_nitro/graphql/debug",
+				handler: join(runtime, "debug"),
+				method: "get"
+			});
+			consola.info("[nitro-graphql] Debug dashboard available at: /_nitro/graphql/debug");
+		}
 		if (nitro.options.imports) {
 			nitro.options.imports.presets ??= [];
 			nitro.options.imports.presets.push({
@@ -193,34 +244,36 @@ var src_default = defineNitroModule({
 			const nuxtOptions = nitro._nuxt?.options;
 			if (nuxtOptions) nuxtOptions.nitroGraphqlExternalServices = nitro.options.graphql?.externalServices || [];
 		});
-		if (!existsSync(join(nitro.options.rootDir, "graphql.config.ts"))) {
-			const schemaPath = relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.buildDir, "schema.graphql"));
-			const documentsPath = relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.clientDir, "**/*.{graphql,js,ts,jsx,tsx}"));
-			writeFileSync(join(nitro.options.rootDir, "graphql.config.ts"), `
+		if (shouldGenerateScaffold(nitro)) {
+			const placeholders = getDefaultPaths(nitro);
+			const scaffoldConfig = getScaffoldConfig(nitro);
+			const graphqlConfigPath = resolveFilePath(scaffoldConfig.graphqlConfig, scaffoldConfig.enabled, true, "graphql.config.ts", placeholders);
+			if (graphqlConfigPath) writeFileIfNotExists(graphqlConfigPath, `
 import type { IGraphQLConfig } from 'graphql-config'
 
 export default <IGraphQLConfig> {
     projects: {
       default: {
         schema: [
-          '${schemaPath}',
+          '${relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.buildDir, "schema.graphql"))}',
         ],
         documents: [
-          '${documentsPath}',
+          '${relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.clientDir, "**/*.{graphql,js,ts,jsx,tsx}"))}',
         ],
       },
     },
-}`, "utf-8");
-		}
-		if (!existsSync(nitro.graphql.serverDir)) mkdirSync(nitro.graphql.serverDir, { recursive: true });
-		if (!existsSync(join(nitro.graphql.serverDir, "schema.ts"))) writeFileSync(join(nitro.graphql.serverDir, "schema.ts"), `
-import { defineSchema } from 'nitro-graphql/utils/define'      
-      
-export default defineSchema({
+}`, "graphql.config.ts");
+			const serverSchemaPath = resolveFilePath(scaffoldConfig.serverSchema, scaffoldConfig.enabled, true, "{serverGraphql}/schema.ts", placeholders);
+			const serverConfigPath = resolveFilePath(scaffoldConfig.serverConfig, scaffoldConfig.enabled, true, "{serverGraphql}/config.ts", placeholders);
+			const serverContextPath = resolveFilePath(scaffoldConfig.serverContext, scaffoldConfig.enabled, true, "{serverGraphql}/context.ts", placeholders);
+			if (serverSchemaPath || serverConfigPath || serverContextPath) {
+				if (!existsSync(nitro.graphql.serverDir)) mkdirSync(nitro.graphql.serverDir, { recursive: true });
+			}
+			if (serverSchemaPath) writeFileIfNotExists(serverSchemaPath, `export default defineSchema({
 
 })
-`, "utf-8");
-		if (!existsSync(join(nitro.graphql.serverDir, "config.ts"))) writeFileSync(join(nitro.graphql.serverDir, "config.ts"), `// Example GraphQL config file please change it to your needs
+`, "server schema.ts");
+			if (serverConfigPath) writeFileIfNotExists(serverConfigPath, `// Example GraphQL config file please change it to your needs
 // import * as tables from '../drizzle/schema/index'
 // import { useDatabase } from '../utils/useDb'
 import { defineGraphQLConfig } from 'nitro-graphql/utils/define'
@@ -236,8 +289,8 @@ export default defineGraphQLConfig({
 //   }
 // },
 })
-`, "utf-8");
-		if (!existsSync(join(nitro.graphql.serverDir, "context.ts"))) writeFileSync(join(nitro.graphql.serverDir, "context.ts"), `// Example context definition - please change it to your needs
+`, "server config.ts");
+			if (serverContextPath) writeFileIfNotExists(serverContextPath, `// Example context definition - please change it to your needs
 // import type { Database } from '../utils/useDb'
 
 declare module 'h3' {
@@ -252,11 +305,12 @@ declare module 'h3' {
     //   }
     // }
   }
-}`, "utf-8");
-		if (existsSync(join(nitro.graphql.serverDir, "context.d.ts"))) {
-			consola.warn("nitro-graphql: Found context.d.ts file. Please rename it to context.ts for the new structure.");
-			consola.info("The context file should now be context.ts instead of context.d.ts");
-		}
+}`, "server context.ts");
+			if (existsSync(join(nitro.graphql.serverDir, "context.d.ts"))) {
+				consola.warn("nitro-graphql: Found context.d.ts file. Please rename it to context.ts for the new structure.");
+				consola.info("The context file should now be context.ts instead of context.d.ts");
+			}
+		} else consola.info("[nitro-graphql] Scaffold file generation is disabled (library mode)");
 	}
 });
 

package/dist/rollup.js

@@ -12,12 +12,16 @@ 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 || {};
+		const { include = /\.(?:graphql|gql)$/i, exclude, validate = false } = app.options.graphql?.loader || {};
 		if (Array.isArray(rollupConfig$1.plugins)) {
 			rollupConfig$1.plugins.push({
 				name: "nitro-graphql",
+				resolveId(id) {
+					if (/\.(?:graphql|gql)$/i.test(id)) return null;
+				},
 				async load(id) {
 					if (exclude?.test?.(id)) return null;
 					if (!include.test(id)) return null;
@@ -50,46 +54,120 @@ function virtualSchemas(app) {
 	const getSchemas = () => [...app.scanSchemas, ...app.options.graphql?.typedefs ?? []];
 	app.options.virtual ??= {};
 	app.options.virtual["#nitro-internal-virtual/server-schemas"] = () => {
-		const imports = getSchemas();
-		return `
-${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")}
 ];
     `;
+			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 = () => [...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 }) => 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");
-		return [
-			...importsContent,
-			"export const resolvers = [",
-			data,
-			"]",
-			""
-		].join("\n");
+		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 = () => 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 }) => 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");
-		return [
-			...importsContent,
-			"export const directives = [",
-			data,
-			"]",
-			""
-		].join("\n");
+		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) {
@@ -109,6 +187,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 h33 from "h3";
 
 //#region src/routes/apollo-server.d.ts
-declare const _default: h30.EventHandler<h30.EventHandlerRequest, unknown>;
+declare const _default: h33.EventHandler<h33.EventHandlerRequest, unknown>;
 //#endregion
 export { _default as default };

package/dist/routes/debug.d.ts

@@ -0,0 +1,15 @@
+import * as h35 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: h35.EventHandler<h35.EventHandlerRequest, unknown>;
+//#endregion
+export { _default as default };