nitro-graphql 1.4.4 → 2.0.0-beta.2

package/dist/ecosystem/nuxt.js

@@ -43,8 +43,7 @@ var nuxt_default = defineNuxtModule({
 			nitroConfig.graphql.layerDirectories = layerDirectories;
 			nitroConfig.graphql.layerServerDirs = layerServerDirs;
 			nitroConfig.graphql.layerAppDirs = layerAppDirs;
-			const appGraphqlDir = resolve(nuxt.options.rootDir, "app/graphql");
-			if (!existsSync(appGraphqlDir)) {
+			if (!existsSync(resolve(nuxt.options.rootDir, "app/graphql"))) {
 				const defaultDir = join(clientDir, "default");
 				if (!existsSync(defaultDir)) mkdirSync(defaultDir, { recursive: true });
 				const sampleQueryFile = join(defaultDir, "queries.graphql");

package/dist/index.js

@@ -7,7 +7,6 @@ import { fileURLToPath } from "node:url";
 import { watch } from "chokidar";
 import consola from "consola";
 import defu from "defu";
-import { defineNitroModule } from "nitropack/kit";
 import { dirname, join, relative, resolve } from "pathe";
 
 //#region src/index.ts
@@ -28,7 +27,7 @@ var src_default = defineNitroModule({
 			buildDir: "",
 			watchDirs: [],
 			clientDir: "",
-			serverDir: resolve(nitro.options.srcDir, "graphql"),
+			serverDir: resolve(nitro.options.rootDir, "server", "graphql"),
 			dir: {
 				build: relative(nitro.options.rootDir, nitro.options.buildDir),
 				client: "graphql",
@@ -73,8 +72,11 @@ var src_default = defineNitroModule({
 				break;
 			}
 			case "nitro":
+				if (!nitro.options.graphql?.serverDir) nitro.graphql.serverDir = resolve(nitro.options.rootDir, "server", "graphql");
 				nitro.graphql.clientDir = resolve(nitro.options.rootDir, "graphql");
 				nitro.graphql.dir.client = "graphql";
+				watchDirs.push(nitro.graphql.clientDir);
+				watchDirs.push(nitro.graphql.serverDir);
 				break;
 			default:
 		}
@@ -91,13 +93,16 @@ var src_default = defineNitroModule({
 			ignoreInitial: true,
 			ignored: [...nitro.options.ignore, ...generateLayerIgnorePatterns(nitro)]
 		}).on("all", async (_, path) => {
-			if (path.endsWith(".graphql") || path.endsWith(".gql")) await clientTypeGeneration(nitro);
+			if (path.endsWith(".graphql") || path.endsWith(".gql")) if (path.includes(nitro.graphql.serverDir) || path.includes("server/graphql") || path.includes("server\\graphql")) {
+				await serverTypeGeneration(nitro);
+				await clientTypeGeneration(nitro);
+				await nitro.hooks.callHook("dev:reload");
+			} else await clientTypeGeneration(nitro);
 		});
 		nitro.hooks.hook("close", () => {
 			watcher.close();
 		});
-		const tsConfigPath = resolve(nitro.options.buildDir, nitro.options.typescript.tsconfigPath);
-		const tsconfigDir = dirname(tsConfigPath);
+		const tsconfigDir = dirname(resolve(nitro.options.buildDir, nitro.options.typescript.tsconfigPath));
 		const typesDir = resolve(nitro.options.buildDir, "types");
 		nitro.scanSchemas = await scanSchemas(nitro);
 		nitro.scanDocuments = await scanDocs(nitro);
@@ -122,9 +127,9 @@ var src_default = defineNitroModule({
 		});
 		const runtime = fileURLToPath(new URL("routes", import.meta.url));
 		const methods = [
-			"get",
-			"post",
-			"options"
+			"GET",
+			"POST",
+			"OPTIONS"
 		];
 		if (nitro.options.graphql?.framework === "graphql-yoga") for (const method of methods) nitro.options.handlers.push({
 			route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
@@ -139,7 +144,7 @@ var src_default = defineNitroModule({
 		nitro.options.handlers.push({
 			route: nitro.options.runtimeConfig.graphql?.endpoint?.healthCheck || "/api/graphql/health",
 			handler: join(runtime, "health"),
-			method: "get"
+			method: "GET"
 		});
 		if (nitro.options.imports) {
 			nitro.options.imports.presets ??= [];
@@ -208,13 +213,17 @@ export default <IGraphQLConfig> {
 }`, "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"), `export default defineSchema({
+		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({
 
 })
 `, "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
 // import * as tables from '../drizzle/schema/index'
 // import { useDatabase } from '../utils/useDb'
+import { defineGraphQLConfig } from 'nitro-graphql/utils/define'
 
 export default defineGraphQLConfig({
 // graphql-yoga example config

package/dist/rollup.js

@@ -37,7 +37,6 @@ async function rollupConfig(app) {
 				async buildStart() {
 					const graphqlFiles = await scanGraphql(nitro);
 					for (const file of graphqlFiles) this.addWatchFile(file);
-					this.addWatchFile(app.graphql.serverDir);
 				}
 			});
 		}
@@ -48,9 +47,7 @@ async function rollupConfig(app) {
 	});
 }
 function virtualSchemas(app) {
-	const getSchemas = () => {
-		return [...app.scanSchemas, ...app.options.graphql?.typedefs ?? []];
-	};
+	const getSchemas = () => [...app.scanSchemas, ...app.options.graphql?.typedefs ?? []];
 	app.options.virtual ??= {};
 	app.options.virtual["#nitro-internal-virtual/server-schemas"] = () => {
 		const imports = getSchemas();
@@ -64,43 +61,35 @@ ${imports.map((h) => `{ def: ${getImportId(h)} }`).join(",\n")}
 	};
 }
 function virtualResolvers(app) {
-	const getResolvers = () => {
-		return [...app.scanResolvers];
-	};
+	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 }) => {
-			return genImport(specifier, imports$1, options);
-		})];
-		const content = [
+		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 = [",
-			imports.map(({ imports: imports$1 }) => imports$1.map((i) => `{ resolver: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n"),
+			data,
 			"]",
 			""
-		];
-		content.unshift(...importsContent);
-		return content.join("\n");
+		].join("\n");
 	};
 }
 function virtualDirectives(app) {
-	const getDirectives = () => {
-		return [...app.scanDirectives || []];
-	};
+	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 }) => {
-			return genImport(specifier, imports$1, options);
-		})];
-		const content = [
+		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 = [",
-			imports.map(({ imports: imports$1 }) => imports$1.map((i) => `{ directive: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n"),
+			data,
 			"]",
 			""
-		];
-		content.unshift(...importsContent);
-		return content.join("\n");
+		].join("\n");
 	};
 }
 function getGraphQLConfig(app) {

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

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

package/dist/routes/apollo-server.js

@@ -26,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
@@ -37,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,
@@ -67,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));
@@ -83,8 +79,7 @@ async function createApolloServer() {
 let serverPromise = null;
 var apollo_server_default = defineEventHandler(async (event) => {
 	if (!serverPromise) serverPromise = createApolloServer();
-	const server = await serverPromise;
-	return startServerAndCreateH3Handler(server, {
+	return startServerAndCreateH3Handler(await serverPromise, {
 		context: async () => ({ event }),
 		serverAlreadyStarted: true
 	})(event);

package/dist/routes/graphql-yoga.d.ts

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

package/dist/routes/graphql-yoga.js

@@ -8,7 +8,7 @@ import { directives } from "#nitro-internal-virtual/server-directives";
 import { resolvers } from "#nitro-internal-virtual/server-resolvers";
 import { schemas } from "#nitro-internal-virtual/server-schemas";
 import { makeExecutableSchema } from "@graphql-tools/schema";
-import { defineEventHandler, toWebRequest } from "h3";
+import { defineEventHandler } from "h3";
 import { createYoga } from "graphql-yoga";
 
 //#region src/routes/graphql-yoga.ts
@@ -41,8 +41,7 @@ new window.EmbeddedSandbox({
 </html>`;
 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
@@ -52,13 +51,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,
@@ -80,17 +77,13 @@ async function createMergedSchema() {
 }
 let yoga;
 var graphql_yoga_default = defineEventHandler(async (event) => {
-	if (!yoga) {
-		const schema = await createMergedSchema();
-		yoga = createYoga(defu({
-			schema,
-			graphqlEndpoint: "/api/graphql",
-			landingPage: false,
-			renderGraphiQL: () => apolloSandboxHtml
-		}, importedConfig));
-	}
-	const request = toWebRequest(event);
-	const response = await yoga.handleRequest(request, event);
+	if (!yoga) yoga = createYoga(defu({
+		schema: await createMergedSchema(),
+		graphqlEndpoint: "/api/graphql",
+		landingPage: false,
+		renderGraphiQL: () => apolloSandboxHtml
+	}, importedConfig));
+	const response = await yoga.handleRequest(event.req, event);
 	return new Response(response.body, response);
 });
 

package/dist/routes/health.d.ts

@@ -1,10 +1,6 @@
 import * as h33 from "h3";
 
 //#region src/routes/health.d.ts
-declare const _default: h33.EventHandler<h33.EventHandlerRequest, Promise<{
-  status: string;
-  message: string;
-  timestamp: string;
-}>>;
+declare const _default: h33.EventHandler<h33.EventHandlerRequest, unknown>;
 //#endregion
 export { _default as default };

package/dist/routes/health.js

@@ -1,11 +1,12 @@
-import { defineEventHandler, setResponseStatus } from "h3";
-import { useRuntimeConfig } from "nitropack/runtime";
+import { defineEventHandler } from "h3";
+import { useRuntimeConfig } from "nitro/runtime";
 
 //#region src/routes/health.ts
 var health_default = defineEventHandler(async (event) => {
 	const runtime = useRuntimeConfig();
 	if (!runtime.graphql || !runtime.graphql.endpoint?.graphql) {
-		setResponseStatus(event, 404);
+		event.res.status = 404;
+		event.res.statusText = "Not Found";
 		return {
 			status: "error",
 			message: "GraphQL health check endpoint is not configured",
@@ -31,7 +32,8 @@ var health_default = defineEventHandler(async (event) => {
 		};
 		throw new Error("Invalid response from GraphQL server");
 	} catch (error) {
-		setResponseStatus(event, 503);
+		event.res.status = 503;
+		event.res.statusText = "Service Unavailable";
 		return {
 			status: "unhealthy",
 			message: error instanceof Error ? error.message : "GraphQL server is not responding",

package/dist/types/index.d.ts

@@ -27,7 +27,7 @@ interface GenImport {
   imports: IESMImport[];
   options?: ESMCodeGenOptions;
 }
-declare module 'nitropack/types' {
+declare module 'nitro/types' {
   interface Nitro {
     scanSchemas: string[];
     scanDocuments: string[];
@@ -46,7 +46,7 @@ declare module 'nitropack/types' {
     };
   }
 }
-declare module 'nitropack' {
+declare module 'nitro/types' {
   interface NitroOptions {
     graphql?: NitroGraphQLOptions;
   }

package/dist/utils/client-codegen.js

@@ -101,15 +101,13 @@ async function downloadAndSaveSchema(service, buildDir) {
 		if (downloadMode === "always") {
 			shouldDownload = true;
 			if (fileExists && hasUrlSchemas) try {
-				const remoteSchema = loadSchemaSync(schemas.filter(isUrl), {
+				const remoteSchemaString = printSchemaWithDirectives(loadSchemaSync(schemas.filter(isUrl), {
 					loaders: [new UrlLoader()],
 					...Object.keys(headers).length > 0 && { headers }
-				});
-				const remoteSchemaString = printSchemaWithDirectives(remoteSchema);
+				}));
 				const remoteHash = createHash("md5").update(remoteSchemaString).digest("hex");
 				const localSchemaString = readFileSync(schemaFilePath, "utf-8");
-				const localHash = createHash("md5").update(localSchemaString).digest("hex");
-				if (remoteHash === localHash) {
+				if (remoteHash === createHash("md5").update(localSchemaString).digest("hex")) {
 					shouldDownload = false;
 					consola$1.info(`[graphql:${service.name}] Schema is up-to-date, using cached version`);
 				}
@@ -134,24 +132,21 @@ async function downloadAndSaveSchema(service, buildDir) {
 		} else if (downloadMode === true || downloadMode === "once") shouldDownload = !fileExists;
 		if (shouldDownload) {
 			if (hasUrlSchemas && hasLocalSchemas) {
-				const schema = loadSchemaSync(schemas, {
+				const schemaString = printSchemaWithDirectives(loadSchemaSync(schemas, {
 					loaders: [new GraphQLFileLoader(), new UrlLoader()],
 					...Object.keys(headers).length > 0 && { headers }
-				});
-				const schemaString = printSchemaWithDirectives(schema);
+				}));
 				mkdirSync(dirname(schemaFilePath), { recursive: true });
 				writeFileSync(schemaFilePath, schemaString, "utf-8");
 			} else if (hasUrlSchemas) {
-				const schema = loadSchemaSync(schemas, {
+				const schemaString = printSchemaWithDirectives(loadSchemaSync(schemas, {
 					loaders: [new UrlLoader()],
 					...Object.keys(headers).length > 0 && { headers }
-				});
-				const schemaString = printSchemaWithDirectives(schema);
+				}));
 				mkdirSync(dirname(schemaFilePath), { recursive: true });
 				writeFileSync(schemaFilePath, schemaString, "utf-8");
 			} else if (hasLocalSchemas) {
-				const schema = loadSchemaSync(schemas, { loaders: [new GraphQLFileLoader()] });
-				const schemaString = printSchemaWithDirectives(schema);
+				const schemaString = printSchemaWithDirectives(loadSchemaSync(schemas, { loaders: [new GraphQLFileLoader()] }));
 				mkdirSync(dirname(schemaFilePath), { recursive: true });
 				writeFileSync(schemaFilePath, schemaString, "utf-8");
 			}
@@ -176,7 +171,7 @@ async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, ou
 		return false;
 	}
 	const serviceLabel = serviceName ? `:${serviceName}` : "";
-	const defaultConfig = {
+	const mergedConfig = defu$1({
 		emitLegacyCommonJSImports: false,
 		useTypeImports: true,
 		enumsAsTypes: true,
@@ -200,8 +195,7 @@ async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, ou
 				output: "File"
 			}
 		}
-	};
-	const mergedConfig = defu$1(defaultConfig, config);
+	}, config);
 	const mergedSdkConfig = defu$1(mergedConfig, sdkConfig);
 	try {
 		if (docs.length === 0) return {
@@ -271,15 +265,14 @@ export function getSdk(requester: Requester): Sdk {
 				typescriptGenericSdk: { plugin: plugin$1 }
 			}
 		});
-		const sdkContent = (await Promise.all(sdkOutput.map(async (config$1) => {
-			return {
-				file: config$1.filename,
-				content: await codegen(config$1)
-			};
-		})))[0]?.content || "";
 		return {
 			types: output,
-			sdk: sdkContent
+			sdk: (await Promise.all(sdkOutput.map(async (config$1) => {
+				return {
+					file: config$1.filename,
+					content: await codegen(config$1)
+				};
+			})))[0]?.content || ""
 		};
 	} catch (error) {
 		consola$1.warn(`[graphql${serviceLabel}] Client type generation failed:`, error);
@@ -290,9 +283,7 @@ export function getSdk(requester: Requester): Sdk {
 * Generate client types for external GraphQL service
 */
 async function generateExternalClientTypes(service, schema, docs) {
-	const config = service.codegen?.client || {};
-	const sdkConfig = service.codegen?.clientSDK || {};
-	return generateClientTypes(schema, docs, config, sdkConfig, void 0, service.name);
+	return generateClientTypes(schema, docs, service.codegen?.client || {}, service.codegen?.clientSDK || {}, void 0, service.name);
 }
 
 //#endregion

package/dist/utils/directive-parser.js

@@ -18,13 +18,9 @@ var DirectiveParser = class {
 				sourceType: "module",
 				astType: "ts"
 			});
-			if (result.errors.length > 0) {
-				console.warn(`Parse errors in ${filePath}:`, result.errors.map((e) => e.message));
-				return [];
-			}
+			if (result.errors.length > 0) return [];
 			return this.extractDirectiveDefinitions(result.program);
-		} catch (error) {
-			console.warn(`Failed to parse ${filePath} with oxc:`, error);
+		} catch {
 			return [];
 		}
 	}
@@ -205,7 +201,7 @@ async function generateDirectiveSchemas(nitro, directives) {
 		}
 	}
 	if (directiveSchemas.length > 0) {
-		const directivesPath = resolve(nitro.graphql.serverDir, "_directives.graphql");
+		const directivesPath = resolve(nitro.graphql.buildDir, "_directives.graphql");
 		const content = `# WARNING: This file is auto-generated by nitro-graphql
 # Do not modify this file directly. It will be overwritten.
 # To define custom directives, create .directive.ts files using defineDirective()

package/dist/utils/index.d.ts

@@ -1,6 +1,6 @@
 import { GenImport } from "../types/index.js";
 import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.js";
-import { Nitro } from "nitropack";
+import { Nitro } from "nitro/types";
 
 //#region src/utils/index.d.ts
 declare const GLOB_SCAN_PATTERN = "**/*.{graphql,gql,js,mjs,cjs,ts,mts,cts,tsx,jsx}";
@@ -19,13 +19,12 @@ declare function getLayerAppDirectories(nitro: Nitro): string[];
 /**
  * Generate layer-aware ignore patterns for auto-generated files
  */
-declare function generateLayerIgnorePatterns(nitro: Nitro): string[];
+declare function generateLayerIgnorePatterns(): string[];
 declare function getImportId(p: string, lazy?: boolean): string;
 declare function relativeWithDot(from: string, to: string): string;
 declare function scanGraphql(nitro: Nitro): Promise<string[]>;
 declare function scanResolvers(nitro: Nitro): Promise<GenImport[]>;
 declare function scanDirectives(nitro: Nitro): Promise<GenImport[]>;
-declare function scanTypeDefs(nitro: Nitro): Promise<string[]>;
 declare function scanSchemas(nitro: Nitro): Promise<string[]>;
 declare function scanDocs(nitro: Nitro): Promise<string[]>;
 /**
@@ -37,4 +36,4 @@ declare function scanExternalServiceDocs(nitro: Nitro, serviceName: string, patt
  */
 declare function validateExternalServices(services: unknown[]): string[];
 //#endregion
-export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };
+export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, validateExternalServices };

package/dist/utils/index.js

@@ -28,12 +28,8 @@ function getLayerAppDirectories(nitro) {
 /**
 * Generate layer-aware ignore patterns for auto-generated files
 */
-function generateLayerIgnorePatterns(nitro) {
-	const patterns = [];
-	patterns.push(`${nitro.graphql.serverDir}/_directives.graphql`);
-	const layerServerDirs = nitro.options.graphql?.layerServerDirs || [];
-	for (const layerServerDir of layerServerDirs) patterns.push(`${layerServerDir}/graphql/_directives.graphql`);
-	return patterns;
+function generateLayerIgnorePatterns() {
+	return [];
 }
 function getImportId(p, lazy) {
 	return (lazy ? "_lazy_" : "_") + hash(p).replace(/-/g, "").slice(0, 6);
@@ -44,10 +40,30 @@ function relativeWithDot(from, to) {
 	return RELATIVE_RE.test(rel) ? rel : `./${rel}`;
 }
 async function scanGraphql(nitro) {
-	return (await scanFiles(nitro, "graphql")).map((f) => f.fullPath);
+	const serverDirRelative = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+	const files = await scanDir(nitro, nitro.options.rootDir, serverDirRelative, "**/*.{graphql,gql}");
+	const layerServerDirs = getLayerServerDirectories(nitro);
+	const layerFiles = await Promise.all(layerServerDirs.map((layerServerDir) => scanDir(nitro, layerServerDir, "graphql", "**/*.{graphql,gql}"))).then((r) => r.flat());
+	const allFiles = [...files, ...layerFiles];
+	const seenPaths = /* @__PURE__ */ new Set();
+	return allFiles.filter((file) => {
+		if (seenPaths.has(file.fullPath)) return false;
+		seenPaths.add(file.fullPath);
+		return true;
+	}).map((f) => f.fullPath);
 }
 async function scanResolvers(nitro) {
-	const files = await scanFiles(nitro, "graphql", "**/*.resolver.{ts,js}");
+	const serverDirRelative = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+	const regularFiles = await scanDir(nitro, nitro.options.rootDir, serverDirRelative, "**/*.resolver.{ts,js}");
+	const layerServerDirs = getLayerServerDirectories(nitro);
+	const layerFiles = await Promise.all(layerServerDirs.map((layerServerDir) => scanDir(nitro, layerServerDir, "graphql", "**/*.resolver.{ts,js}"))).then((r) => r.flat());
+	const allFiles = [...regularFiles, ...layerFiles];
+	const seenPaths = /* @__PURE__ */ new Set();
+	const files = allFiles.filter((file) => {
+		if (seenPaths.has(file.fullPath)) return false;
+		seenPaths.add(file.fullPath);
+		return true;
+	});
 	const exportName = [];
 	for (const file of files) {
 		const fileContent = await readFile(file.fullPath, "utf-8");
@@ -97,7 +113,17 @@ async function scanResolvers(nitro) {
 	return exportName;
 }
 async function scanDirectives(nitro) {
-	const files = await scanFiles(nitro, "graphql", "**/*.directive.{ts,js}");
+	const serverDirRelative = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+	const regularFiles = await scanDir(nitro, nitro.options.rootDir, serverDirRelative, "**/*.directive.{ts,js}");
+	const layerServerDirs = getLayerServerDirectories(nitro);
+	const layerFiles = await Promise.all(layerServerDirs.map((layerServerDir) => scanDir(nitro, layerServerDir, "graphql", "**/*.directive.{ts,js}"))).then((r) => r.flat());
+	const allFiles = [...regularFiles, ...layerFiles];
+	const seenPaths = /* @__PURE__ */ new Set();
+	const files = allFiles.filter((file) => {
+		if (seenPaths.has(file.fullPath)) return false;
+		seenPaths.add(file.fullPath);
+		return true;
+	});
 	const exportName = [];
 	for (const file of files) {
 		const fileContent = await readFile(file.fullPath, "utf-8");
@@ -121,11 +147,18 @@ async function scanDirectives(nitro) {
 	}
 	return exportName;
 }
-async function scanTypeDefs(nitro) {
-	return (await scanFiles(nitro, "graphql", "**/*.typedef.{ts,js}")).map((f) => f.fullPath);
-}
 async function scanSchemas(nitro) {
-	return (await scanFiles(nitro, "graphql", "**/*.graphql")).map((f) => f.fullPath);
+	const serverDirRelative = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+	const files = await scanDir(nitro, nitro.options.rootDir, serverDirRelative, "**/*.graphql");
+	const layerServerDirs = getLayerServerDirectories(nitro);
+	const layerFiles = await Promise.all(layerServerDirs.map((layerServerDir) => scanDir(nitro, layerServerDir, "graphql", "**/*.graphql"))).then((r) => r.flat());
+	const allFiles = [...files, ...layerFiles];
+	const seenPaths = /* @__PURE__ */ new Set();
+	return allFiles.filter((file) => {
+		if (seenPaths.has(file.fullPath)) return false;
+		seenPaths.add(file.fullPath);
+		return true;
+	}).map((f) => f.fullPath);
 }
 async function scanDocs(nitro) {
 	const files = await scanDir(nitro, nitro.options.rootDir, nitro.graphql.dir.client, "**/*.graphql");
@@ -143,9 +176,7 @@ async function scanDocs(nitro) {
 		const relativePath = f.path;
 		for (const pattern of externalPatterns) {
 			const clientDirPattern = `${nitro.graphql.dir.client}/`;
-			const patternDir = pattern.replace(/* @__PURE__ */ new RegExp(`^${clientDirPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`), "").split("/")[0];
-			const fileDir = relativePath.split("/")[0];
-			if (patternDir === fileDir) return false;
+			if (pattern.replace(/* @__PURE__ */ new RegExp(`^${clientDirPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`), "").split("/")[0] === relativePath.split("/")[0]) return false;
 		}
 		return true;
 	}).map((f) => f.fullPath);
@@ -195,18 +226,6 @@ function validateExternalServices(services) {
 	}
 	return errors;
 }
-async function scanFiles(nitro, name, globPattern = GLOB_SCAN_PATTERN) {
-	const regularFiles = await Promise.all(nitro.options.scanDirs.map((dir) => scanDir(nitro, dir, name, globPattern))).then((r) => r.flat());
-	const layerDirectories = getLayerDirectories(nitro);
-	const layerFiles = await Promise.all(layerDirectories.map((layerDir) => scanDir(nitro, layerDir, `server/${name}`, globPattern))).then((r) => r.flat());
-	const allFiles = [...regularFiles, ...layerFiles];
-	const seenPaths = /* @__PURE__ */ new Set();
-	return allFiles.filter((file) => {
-		if (seenPaths.has(file.fullPath)) return false;
-		seenPaths.add(file.fullPath);
-		return true;
-	});
-}
 async function scanDir(nitro, dir, name, globPattern = GLOB_SCAN_PATTERN) {
 	return (await glob(join(name, globPattern), {
 		cwd: dir,
@@ -228,4 +247,4 @@ async function scanDir(nitro, dir, name, globPattern = GLOB_SCAN_PATTERN) {
 }
 
 //#endregion
-export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };
+export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, validateExternalServices };

package/dist/utils/server-codegen.js

@@ -21,7 +21,7 @@ function pluginContent(_schema, _documents, _config, _info) {
 	};
 }
 async function generateTypes(selectFremework, schema, config = {}, outputPath) {
-	const defaultConfig = {
+	const mergedConfig = defu$1({
 		scalars: {
 			DateTime: DateTimeResolver.extensions.codegenScalarType,
 			DateTimeISO: DateTimeISOResolver.extensions.codegenScalarType,
@@ -43,8 +43,7 @@ async function generateTypes(selectFremework, schema, config = {}, outputPath) {
 		declarationKind: "interface",
 		enumsAsTypes: true,
 		...config.federation?.enabled && { federation: true }
-	};
-	const mergedConfig = defu$1(defaultConfig, config.codegen?.server);
+	}, config.codegen?.server);
 	return await codegen({
 		filename: outputPath || "types.generated.ts",
 		schema: parse(printSchemaWithDirectives(schema)),

package/dist/utils/type-generation.d.ts

@@ -1,4 +1,4 @@
-import { Nitro } from "nitropack";
+import { Nitro } from "nitro/types";
 
 //#region src/utils/type-generation.d.ts
 declare function serverTypeGeneration(app: Nitro): Promise<void>;

package/dist/utils/type-generation.js

@@ -27,16 +27,20 @@ export * from './default/ofetch'
 		writeFileSync(indexPath, indexContent, "utf-8");
 	}
 }
-function generateNuxtOfetchClient(clientDir, serviceName = "default") {
+function generateOfetchClient(clientDir, serviceName, endpoint, isDefault = false) {
 	const serviceDir = resolve(clientDir, serviceName);
 	const ofetchPath = resolve(serviceDir, "ofetch.ts");
 	if (!existsSync(serviceDir)) mkdirSync(serviceDir, { recursive: true });
-	if (!existsSync(ofetchPath)) writeFileSync(ofetchPath, `// This file is auto-generated once by nitro-graphql for quick start
+	if (existsSync(ofetchPath)) return;
+	const capitalizedServiceName = serviceName.charAt(0).toUpperCase() + serviceName.slice(1);
+	const functionName = isDefault ? "createGraphQLClient" : `create${capitalizedServiceName}GraphQLClient`;
+	const exportName = isDefault ? "$sdk" : `$${serviceName}Sdk`;
+	writeFileSync(ofetchPath, `// This file is auto-generated once by nitro-graphql for quick start
 // You can modify this file according to your needs
-import type { Requester } from './sdk'
+import type { ${isDefault ? "Requester" : "Sdk, Requester"} } from './sdk'
 import { getSdk } from './sdk'
 
-export function createGraphQLClient(endpoint: string): Requester {
+export function ${functionName}(endpoint: string${isDefault ? "" : ` = '${endpoint}'`}): Requester {
   return async <R>(doc: string, vars?: any): Promise<R> => {
     const headers = import.meta.server ? useRequestHeaders() : undefined
 
@@ -53,39 +57,7 @@ export function createGraphQLClient(endpoint: string): Requester {
   }
 }
 
-export const $sdk = getSdk(createGraphQLClient('/api/graphql'))`, "utf-8");
-}
-function generateExternalOfetchClient(clientDir, serviceName, endpoint) {
-	const serviceDir = resolve(clientDir, serviceName);
-	const ofetchPath = resolve(serviceDir, "ofetch.ts");
-	if (!existsSync(serviceDir)) mkdirSync(serviceDir, { recursive: true });
-	if (!existsSync(ofetchPath)) {
-		const capitalizedServiceName = serviceName.charAt(0).toUpperCase() + serviceName.slice(1);
-		const ofetchContent = `// This file is auto-generated once by nitro-graphql for quick start
-// You can modify this file according to your needs
-import type { Sdk, Requester } from './sdk'
-import { getSdk } from './sdk'
-
-export function create${capitalizedServiceName}GraphQLClient(endpoint: string = '${endpoint}'): Requester {
-  return async <R>(doc: string, vars?: any): Promise<R> => {
-    const headers = import.meta.server ? useRequestHeaders() : undefined
-
-    const result = await $fetch(endpoint, {
-      method: 'POST',
-      body: { query: doc, variables: vars },
-      headers: {
-        'Content-Type': 'application/json',
-        ...headers,
-      },
-    })
-
-    return result as R
-  }
-}
-
-export const $${serviceName}Sdk: Sdk = getSdk(create${capitalizedServiceName}GraphQLClient())`;
-		writeFileSync(ofetchPath, ofetchContent, "utf-8");
-	}
+export const ${exportName}${isDefault ? "" : ": Sdk"} = getSdk(${functionName}(${isDefault ? "'/api/graphql'" : ""}))`, "utf-8");
 }
 /**
 * Check for duplicate type definitions using a simpler approach
@@ -251,8 +223,7 @@ async function generateMainClientTypes(nitro) {
 		return;
 	}
 	const graphqlString = readFileSync(schemaFilePath, "utf-8");
-	const schema = nitro.options.graphql?.federation?.enabled === true ? buildSubgraphSchema([{ typeDefs: parse(graphqlString) }]) : buildSchema(graphqlString);
-	const types = await generateClientTypes(schema, loadDocs, nitro.options.graphql?.codegen?.client ?? {}, nitro.options.graphql?.codegen?.clientSDK ?? {});
+	const types = await generateClientTypes(nitro.options.graphql?.federation?.enabled === true ? buildSubgraphSchema([{ typeDefs: parse(graphqlString) }]) : buildSchema(graphqlString), loadDocs, nitro.options.graphql?.codegen?.client ?? {}, nitro.options.graphql?.codegen?.clientSDK ?? {});
 	if (types === false) return;
 	const clientTypesPath = resolve(nitro.options.buildDir, "types", "nitro-graphql-client.d.ts");
 	const defaultServiceDir = resolve(nitro.graphql.clientDir, "default");
@@ -260,9 +231,11 @@ async function generateMainClientTypes(nitro) {
 	mkdirSync(dirname(clientTypesPath), { recursive: true });
 	writeFileSync(clientTypesPath, types.types, "utf-8");
 	mkdirSync(defaultServiceDir, { recursive: true });
-	writeFileSync(sdkTypesPath, types.sdk, "utf-8");
+	let shouldWriteSdk = true;
+	if (existsSync(sdkTypesPath)) shouldWriteSdk = readFileSync(sdkTypesPath, "utf-8") !== types.sdk;
+	if (shouldWriteSdk) writeFileSync(sdkTypesPath, types.sdk, "utf-8");
 	if (nitro.options.framework?.name === "nuxt") {
-		generateNuxtOfetchClient(nitro.graphql.clientDir, "default");
+		generateOfetchClient(nitro.graphql.clientDir, "default", "/api/graphql", true);
 		const externalServices = nitro.options.graphql?.externalServices || [];
 		generateGraphQLIndexFile(nitro.graphql.clientDir, externalServices);
 	}
@@ -300,8 +273,10 @@ async function generateExternalServicesTypes(nitro) {
 		mkdirSync(dirname(serviceTypesPath), { recursive: true });
 		writeFileSync(serviceTypesPath, types.types, "utf-8");
 		mkdirSync(serviceDir, { recursive: true });
-		writeFileSync(serviceSdkPath, types.sdk, "utf-8");
-		if (nitro.options.framework?.name === "nuxt") generateExternalOfetchClient(nitro.graphql.clientDir, service.name, service.endpoint);
+		let shouldWriteServiceSdk = true;
+		if (existsSync(serviceSdkPath)) shouldWriteServiceSdk = readFileSync(serviceSdkPath, "utf-8") !== types.sdk;
+		if (shouldWriteServiceSdk) writeFileSync(serviceSdkPath, types.sdk, "utf-8");
+		if (nitro.options.framework?.name === "nuxt") generateOfetchClient(nitro.graphql.clientDir, service.name, service.endpoint, false);
 		consola.success(`[graphql:${service.name}] External service types generated successfully`);
 	} catch (error) {
 		consola.error(`[graphql:${service.name}] External service generation failed:`, error);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nitro-graphql",
   "type": "module",
-  "version": "1.4.4",
+  "version": "2.0.0-beta.2",
   "description": "GraphQL integration for Nitro",
   "license": "MIT",
   "sideEffects": false,
@@ -63,8 +63,8 @@
     "@apollo/utils.withrequired": "^3.0.0",
     "@as-integrations/h3": "^2.0.0",
     "graphql": "^16.11.0",
-    "h3": "^1.15.3",
-    "nitropack": "^2.11.13"
+    "h3": "^2.0.1-rc.2",
+    "nitro": "^3.0.1-alpha.0"
   },
   "peerDependenciesMeta": {
     "@apollo/server": {
@@ -114,8 +114,8 @@
     "eslint": "^9.37.0",
     "graphql": "16.11.0",
     "graphql-yoga": "^5.16.0",
-    "h3": "1.15.3",
-    "nitropack": "^2.12.6",
+    "h3": "^2.0.1-rc.2",
+    "nitro": "^3.0.1-alpha.0",
     "tsdown": "^0.15.6",
     "typescript": "^5.9.3"
   },