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

package/dist/setup.mjs

@@ -1,40 +1,51 @@
-import { generateDirectiveSchemas } from "./utils/directive-parser.mjs";
-import { generateLayerIgnorePatterns, getLayerAppDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanResolvers, scanSchemas, validateExternalServices } from "./utils/index.mjs";
-import { writeFileIfNotExists } from "./utils/file-generator.mjs";
-import { getScaffoldConfig, getTypesConfig, resolveFilePath, shouldGenerateScaffold } from "./utils/path-resolver.mjs";
-import { clientTypeGeneration, serverTypeGeneration } from "./utils/type-generation.mjs";
+import { ENDPOINT_DEBUG, FRAMEWORK_NITRO, FRAMEWORK_NUXT, GRAPHQL_HTTP_METHODS, LOG_TAG } from "./constants.mjs";
+import { getDefaultPaths } from "./utils/path-resolver.mjs";
+import { generateServerTypes } from "./codegen/server-types.mjs";
+import { generateClientTypes } from "./codegen/index.mjs";
+import { DEFAULT_RUNTIME_CONFIG, DEFAULT_TYPESCRIPT_STRICT, DEFAULT_TYPES_CONFIG } from "./config/defaults.mjs";
+import { validateExternalServices } from "./utils/validation.mjs";
 import { rollupConfig } from "./rollup.mjs";
+import { getWatchDirectories, setupFileWatcher } from "./setup/file-watcher.mjs";
+import { scanAllGraphQLFiles } from "./setup/graphql-scanner.mjs";
+import { setupRollupChunking, setupRollupExternals } from "./setup/rollup-integration.mjs";
+import { generateScaffoldFiles } from "./setup/scaffold-generator.mjs";
+import { setupTypeScriptPaths } from "./setup/ts-config.mjs";
 import defu from "defu";
-import { existsSync, mkdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { watch } from "chokidar";
 import consola from "consola";
-import { dirname, join, relative, resolve } from "pathe";
+import { join, relative, resolve } from "pathe";
 
 //#region src/setup.ts
-const logger = consola.withTag("nitro-graphql");
+const logger = consola.withTag(LOG_TAG);
 /**
-* Shared setup logic for nitro-graphql module
-* Used by both the direct Nitro module export and the Vite plugin's nitro: hook
+* Main setup function for nitro-graphql
+* Coordinates all initialization steps for the module
 */
 async function setupNitroGraphQL(nitro) {
+	initializeConfiguration(nitro);
+	validateConfiguration(nitro);
+	setupBuildDirectories(nitro);
+	setupRollupExternals(nitro);
+	setupRollupChunking(nitro);
+	initializeRuntimeConfig(nitro);
+	setupFileWatching(nitro);
+	await scanGraphQLFiles(nitro);
+	setupDevHooks(nitro);
+	await rollupConfig(nitro);
+	await generateTypes(nitro);
+	setupCloseHooks(nitro);
+	registerRouteHandlers(nitro);
+	setupTypeScriptConfiguration(nitro);
+	setupNuxtIntegration(nitro);
+	generateScaffoldFiles(nitro);
+}
+/**
+* Initialize default configuration values
+*/
+function initializeConfiguration(nitro) {
 	nitro.options.graphql ||= {};
-	nitro.options.graphql.types = defu(nitro.options.graphql.types, {
-		server: ".graphql/nitro-graphql-server.d.ts",
-		client: ".graphql/nitro-graphql-client.d.ts",
-		enabled: true
-	});
+	nitro.options.graphql.types = defu(nitro.options.graphql.types, DEFAULT_TYPES_CONFIG);
 	if (!nitro.options.graphql?.framework) logger.warn("No GraphQL framework specified. Please set graphql.framework to \"graphql-yoga\" or \"apollo-server\".");
-	if (nitro.options.graphql?.externalServices?.length) {
-		const validationErrors = validateExternalServices(nitro.options.graphql.externalServices);
-		if (validationErrors.length > 0) {
-			logger.error("External services configuration errors:");
-			for (const error of validationErrors) logger.error(`  - ${error}`);
-			throw new Error("Invalid external services configuration");
-		}
-		logger.info(`Configured ${nitro.options.graphql.externalServices.length} external GraphQL services`);
-	}
-	const { getDefaultPaths } = await import("./utils/path-resolver.mjs");
 	const defaultPaths = getDefaultPaths(nitro);
 	nitro.graphql ||= {
 		buildDir: "",
@@ -47,143 +58,130 @@ async function setupNitroGraphQL(nitro) {
 			server: "server"
 		}
 	};
-	nitro.hooks.hook("rollup:before", (_, rollupConfig$1) => {
-		rollupConfig$1.external = rollupConfig$1.external || [];
-		const allExternals = [...["oxc-parser", "@oxc-parser"]];
-		if (!nitro.options.graphql?.federation?.enabled) allExternals.push(...[
-			"@apollo/subgraph",
-			"@apollo/federation-internals",
-			"@apollo/cache-control-types"
-		]);
-		if (Array.isArray(rollupConfig$1.external)) rollupConfig$1.external.push(...allExternals);
-		else if (typeof rollupConfig$1.external === "function") {
-			const originalExternal = rollupConfig$1.external;
-			rollupConfig$1.external = (id, parent, isResolved) => {
-				if (allExternals.some((external) => id.includes(external))) return true;
-				return originalExternal(id, parent, isResolved);
-			};
+}
+/**
+* Validate external services configuration
+*/
+function validateConfiguration(nitro) {
+	if (nitro.options.graphql?.externalServices?.length) {
+		const validationErrors = validateExternalServices(nitro.options.graphql.externalServices);
+		if (validationErrors.length > 0) {
+			logger.error("External services configuration errors:");
+			for (const error of validationErrors) logger.error(`  - ${error}`);
+			throw new Error("Invalid external services configuration");
 		}
-	});
-	nitro.options.runtimeConfig.graphql = defu(nitro.options.runtimeConfig.graphql || {}, {
-		endpoint: {
-			graphql: "/api/graphql",
-			healthCheck: "/api/graphql/health"
-		},
-		playground: true
-	});
+		logger.info(`Configured ${nitro.options.graphql.externalServices.length} external GraphQL services`);
+	}
 	if (nitro.options.graphql?.federation?.enabled) logger.info(`Apollo Federation enabled for service: ${nitro.options.graphql.federation.serviceName || "unnamed"}`);
+}
+/**
+* Setup build directories
+*/
+function setupBuildDirectories(nitro) {
 	const graphqlBuildDir = resolve(nitro.options.buildDir, "graphql");
 	nitro.graphql.buildDir = graphqlBuildDir;
-	const watchDirs = [];
 	switch (nitro.options.framework.name) {
-		case "nuxt": {
+		case FRAMEWORK_NUXT:
 			nitro.graphql.dir.client = relative(nitro.options.rootDir, nitro.graphql.clientDir);
 			nitro.graphql.dir.server = relative(nitro.options.rootDir, nitro.graphql.serverDir);
-			watchDirs.push(nitro.graphql.clientDir);
-			const layerServerDirs = getLayerServerDirectories(nitro);
-			const layerAppDirs = getLayerAppDirectories(nitro);
-			for (const layerServerDir of layerServerDirs) watchDirs.push(join(layerServerDir, "graphql"));
-			for (const layerAppDir of layerAppDirs) watchDirs.push(join(layerAppDir, "graphql"));
 			break;
-		}
-		case "nitro":
+		case FRAMEWORK_NITRO:
 			nitro.graphql.dir.client = relative(nitro.options.rootDir, nitro.graphql.clientDir);
 			nitro.graphql.dir.server = relative(nitro.options.rootDir, nitro.graphql.serverDir);
-			watchDirs.push(nitro.graphql.clientDir);
-			watchDirs.push(nitro.graphql.serverDir);
 			break;
-		default:
+		default: break;
 	}
-	if (nitro.options.graphql?.externalServices?.length) {
-		for (const service of nitro.options.graphql.externalServices) if (service.documents?.length) for (const pattern of service.documents) {
-			if (!pattern) continue;
-			const baseDir = pattern.split("**")[0]?.replace(/\/$/, "") || ".";
-			const resolvedDir = resolve(nitro.options.rootDir, baseDir);
-			if (!watchDirs.includes(resolvedDir)) watchDirs.push(resolvedDir);
-		}
-	}
-	const watcher = watch(watchDirs, {
-		persistent: true,
-		ignoreInitial: true,
-		ignored: [...nitro.options.ignore, ...generateLayerIgnorePatterns()]
-	}).on("all", async (_, path) => {
-		const isGraphQLFile = path.endsWith(".graphql") || path.endsWith(".gql");
-		const isResolverFile = path.endsWith(".resolver.ts") || path.endsWith(".resolver.js");
-		const isDirectiveFile = path.endsWith(".directive.ts") || path.endsWith(".directive.js");
-		if (isGraphQLFile || isResolverFile || isDirectiveFile) if (path.includes(nitro.graphql.serverDir) || path.includes("server/graphql") || path.includes("server\\graphql") || isResolverFile || isDirectiveFile) {
-			await scanResolvers(nitro).then((r) => nitro.scanResolvers = r);
-			await scanDirectives(nitro).then((d) => nitro.scanDirectives = d);
-			logger.success("Types regenerated");
-			await serverTypeGeneration(nitro, { silent: true });
-			await clientTypeGeneration(nitro, { silent: true });
-			await nitro.hooks.callHook("dev:reload");
-		} else {
-			logger.success("Types regenerated");
-			await clientTypeGeneration(nitro, { silent: true });
-		}
-	});
+}
+/**
+* Initialize runtime configuration
+*/
+function initializeRuntimeConfig(nitro) {
+	nitro.options.runtimeConfig.graphql = defu(nitro.options.runtimeConfig.graphql || {}, DEFAULT_RUNTIME_CONFIG);
+}
+/**
+* Setup file watching for development mode
+*/
+function setupFileWatching(nitro) {
+	const watchDirs = getWatchDirectories(nitro);
+	nitro.graphql.watchDirs = watchDirs;
+	const watcher = setupFileWatcher(nitro, watchDirs);
 	nitro.hooks.hook("close", () => {
 		watcher.close();
 	});
-	const tsconfigDir = dirname(resolve(nitro.options.buildDir, nitro.options.typescript.tsconfigPath));
-	nitro.scanSchemas = await scanSchemas(nitro);
-	nitro.scanDocuments = await scanDocs(nitro);
-	nitro.scanResolvers = await scanResolvers(nitro);
-	const directives = await scanDirectives(nitro);
-	nitro.scanDirectives = directives;
-	await generateDirectiveSchemas(nitro, directives);
+}
+/**
+* Scan all GraphQL files (schemas, resolvers, directives, documents)
+*/
+async function scanGraphQLFiles(nitro) {
+	await scanAllGraphQLFiles(nitro);
+}
+/**
+* Setup dev mode hooks for rescanning files
+*/
+function setupDevHooks(nitro) {
 	let hasShownInitialLogs = false;
 	nitro.hooks.hook("dev:start", async () => {
-		nitro.scanSchemas = await scanSchemas(nitro);
-		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);
+		await scanAllGraphQLFiles(nitro);
 		if (nitro.options.dev && !hasShownInitialLogs) {
 			hasShownInitialLogs = true;
-			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) logger.success(`${totalExports} resolver export(s): ${breakdown.join(", ")}`);
-			} else logger.warn("No resolvers found. Check /_nitro/graphql/debug for details.");
+			logResolverDiagnostics(nitro);
 		}
 	});
-	await rollupConfig(nitro);
-	await serverTypeGeneration(nitro);
-	await clientTypeGeneration(nitro, { isInitial: true });
+}
+/**
+* Log resolver diagnostics for development
+*/
+function logResolverDiagnostics(nitro) {
+	const resolvers = nitro.scanResolvers || [];
+	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) logger.success(`${totalExports} resolver export(s): ${breakdown.join(", ")}`);
+	} else logger.warn("No resolvers found. Check /_nitro/graphql/debug for details.");
+}
+/**
+* Generate server and client types
+*/
+async function generateTypes(nitro) {
+	await generateServerTypes(nitro);
+	await generateClientTypes(nitro, { isInitial: true });
+}
+/**
+* Setup close hooks for final type generation
+*/
+function setupCloseHooks(nitro) {
 	nitro.hooks.hook("close", async () => {
-		await serverTypeGeneration(nitro, { silent: true });
-		await clientTypeGeneration(nitro, { silent: true });
+		await generateServerTypes(nitro, { silent: true });
+		await generateClientTypes(nitro, { silent: true });
 	});
+}
+/**
+* Register GraphQL route handlers
+*/
+function registerRouteHandlers(nitro) {
 	const runtime = fileURLToPath(new URL("routes", import.meta.url));
-	const methods = [
-		"GET",
-		"POST",
-		"OPTIONS"
-	];
-	if (nitro.options.graphql?.framework === "graphql-yoga") for (const method of methods) nitro.options.handlers.push({
+	const framework = nitro.options.graphql?.framework;
+	if (framework === "graphql-yoga") for (const method of GRAPHQL_HTTP_METHODS) nitro.options.handlers.push({
 		route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
 		handler: join(runtime, "graphql-yoga"),
 		method
 	});
-	if (nitro.options.graphql?.framework === "apollo-server") for (const method of methods) nitro.options.handlers.push({
+	if (framework === "apollo-server") for (const method of GRAPHQL_HTTP_METHODS) nitro.options.handlers.push({
 		route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
 		handler: join(runtime, "apollo-server"),
 		method
@@ -194,182 +192,28 @@ async function setupNitroGraphQL(nitro) {
 		method: "GET"
 	});
 	if (nitro.options.dev) nitro.options.handlers.push({
-		route: "/_nitro/graphql/debug",
+		route: ENDPOINT_DEBUG,
 		handler: join(runtime, "debug"),
 		method: "GET"
 	});
-	nitro.hooks.hook("rollup:before", (_, rollupConfig$1) => {
-		const manualChunks = rollupConfig$1.output?.manualChunks;
-		const chunkFiles = rollupConfig$1.output?.chunkFileNames;
-		if (!rollupConfig$1.output.inlineDynamicImports) {
-			rollupConfig$1.output.manualChunks = (id, meta) => {
-				if (id.endsWith(".graphql") || id.endsWith(".gql")) {
-					let graphqlIndex = id.indexOf("server/graphql/");
-					let baseLength = 15;
-					if (graphqlIndex === -1) {
-						graphqlIndex = id.indexOf("routes/graphql/");
-						baseLength = 15;
-					}
-					if (graphqlIndex !== -1) return id.slice(graphqlIndex + baseLength).replace(/\.(?:graphql|gql)$/, "-schema");
-					return "schemas";
-				}
-				if (id.endsWith(".resolver.ts")) {
-					let graphqlIndex = id.indexOf("server/graphql/");
-					let baseLength = 15;
-					if (graphqlIndex === -1) {
-						graphqlIndex = id.indexOf("routes/graphql/");
-						baseLength = 15;
-					}
-					if (graphqlIndex !== -1) return id.slice(graphqlIndex + baseLength).replace(/\.resolver\.ts$/, "");
-					return "resolvers";
-				}
-				if (typeof manualChunks === "function") return manualChunks(id, meta);
-			};
-			rollupConfig$1.output.advancedChunks = {
-				groups: [{
-					name: (moduleId) => {
-						if (!moduleId.endsWith(".graphql") && !moduleId.endsWith(".gql")) return;
-						let graphqlIndex = moduleId.indexOf("server/graphql/");
-						let baseLength = 15;
-						if (graphqlIndex === -1) {
-							graphqlIndex = moduleId.indexOf("routes/graphql/");
-							baseLength = 15;
-						}
-						if (graphqlIndex !== -1) return moduleId.slice(graphqlIndex + baseLength).replace(/\.(?:graphql|gql)$/, "-schema");
-						return "schemas";
-					},
-					test: /\.(?:graphql|gql)$/
-				}, {
-					name: (moduleId) => {
-						if (!moduleId.endsWith(".resolver.ts")) return;
-						let graphqlIndex = moduleId.indexOf("server/graphql/");
-						let baseLength = 15;
-						if (graphqlIndex === -1) {
-							graphqlIndex = moduleId.indexOf("routes/graphql/");
-							baseLength = 15;
-						}
-						if (graphqlIndex !== -1) return moduleId.slice(graphqlIndex + baseLength).replace(/\.resolver\.ts$/, "");
-						return "resolvers";
-					},
-					test: /\.resolver\.(?:ts|js)$/
-				}],
-				minSize: 0,
-				minShareCount: 1
-			};
-		}
-		rollupConfig$1.output.chunkFileNames = (chunkInfo) => {
-			if (chunkInfo.moduleIds && chunkInfo.moduleIds.some((id) => id.endsWith(".graphql") || id.endsWith(".resolver.ts") || id.endsWith(".gql"))) return `chunks/graphql/[name].mjs`;
-			if (typeof chunkFiles === "function") return chunkFiles(chunkInfo);
-			return `chunks/_/[name].mjs`;
-		};
-	});
-	nitro.options.typescript.strict = true;
+}
+/**
+* Setup TypeScript configuration and path aliases
+*/
+function setupTypeScriptConfiguration(nitro) {
+	nitro.options.typescript.strict = DEFAULT_TYPESCRIPT_STRICT;
 	nitro.hooks.hook("types:extend", (types) => {
-		types.tsConfig ||= {};
-		types.tsConfig.compilerOptions ??= {};
-		types.tsConfig.compilerOptions.paths ??= {};
-		const placeholders = getDefaultPaths(nitro);
-		const typesConfig = getTypesConfig(nitro);
-		const serverTypesPath = resolveFilePath(typesConfig.server, typesConfig.enabled, true, "{typesDir}/nitro-graphql-server.d.ts", placeholders);
-		if (serverTypesPath) types.tsConfig.compilerOptions.paths["#graphql/server"] = [relativeWithDot(tsconfigDir, serverTypesPath)];
-		const clientTypesPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
-		if (clientTypesPath) types.tsConfig.compilerOptions.paths["#graphql/client"] = [relativeWithDot(tsconfigDir, clientTypesPath)];
-		types.tsConfig.compilerOptions.paths["#graphql/schema"] = [relativeWithDot(tsconfigDir, join(nitro.graphql.serverDir, "schema.ts"))];
-		if (nitro.options.graphql?.externalServices?.length) for (const service of nitro.options.graphql.externalServices) {
-			const servicePlaceholders = {
-				...placeholders,
-				serviceName: service.name
-			};
-			const externalTypesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", servicePlaceholders);
-			if (externalTypesPath) types.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [relativeWithDot(tsconfigDir, externalTypesPath)];
-		}
-		types.tsConfig.include = types.tsConfig.include || [];
-		if (serverTypesPath) types.tsConfig.include.push(relativeWithDot(tsconfigDir, serverTypesPath));
-		if (clientTypesPath) types.tsConfig.include.push(relativeWithDot(tsconfigDir, clientTypesPath));
-		types.tsConfig.include.push(relativeWithDot(tsconfigDir, join(placeholders.typesDir, "graphql.d.ts")));
-		if (nitro.options.graphql?.externalServices?.length) for (const service of nitro.options.graphql.externalServices) {
-			const servicePlaceholders = {
-				...placeholders,
-				serviceName: service.name
-			};
-			const externalTypesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", servicePlaceholders);
-			if (externalTypesPath) types.tsConfig.include.push(relativeWithDot(tsconfigDir, externalTypesPath));
-		}
+		setupTypeScriptPaths(nitro, types);
 	});
-	if (nitro.options.framework?.name === "nuxt" && nitro.options.graphql?.externalServices?.length) nitro.hooks.hook("build:before", () => {
+}
+/**
+* Setup Nuxt-specific integration
+*/
+function setupNuxtIntegration(nitro) {
+	if (nitro.options.framework?.name === FRAMEWORK_NUXT && nitro.options.graphql?.externalServices?.length) nitro.hooks.hook("build:before", () => {
 		const nuxtOptions = nitro._nuxt?.options;
 		if (nuxtOptions) nuxtOptions.nitroGraphqlExternalServices = nitro.options.graphql?.externalServices || [];
 	});
-	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: [
-          '${relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.buildDir, "schema.graphql"))}',
-        ],
-        documents: [
-          '${relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.clientDir, "**/*.{graphql,js,ts,jsx,tsx}"))}',
-        ],
-      },
-    },
-}`, "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.d.ts", placeholders);
-		if (serverSchemaPath || serverConfigPath || serverContextPath) {
-			if (!existsSync(nitro.graphql.serverDir)) mkdirSync(nitro.graphql.serverDir, { recursive: true });
-		}
-		if (serverSchemaPath) writeFileIfNotExists(serverSchemaPath, `export default defineSchema({
-
-})
-`, "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/define'
-
-export default defineGraphQLConfig({
-// graphql-yoga example config
-// context: () => {
-//   return {
-//     context: {
-//       useDatabase,
-//       tables,
-//     },
-//   }
-// },
-})
-`, "server config.ts");
-		if (serverContextPath) writeFileIfNotExists(serverContextPath, `// Example context definition - please change it to your needs
-// import type { Database } from '../utils/useDb'
-
-declare module 'nitro/h3' {
-  interface H3EventContext {
-    // Add your custom context properties here
-    // useDatabase: () => Database
-    // tables: typeof import('../drizzle/schema')
-    // auth?: {
-    //   user?: {
-    //     id: string
-    //     role: 'admin' | 'user'
-    //   }
-    // }
-  }
-}
-
-export {}
-`, "server context.d.ts");
-		if (existsSync(join(nitro.graphql.serverDir, "context.ts"))) {
-			logger.warn("Found context.ts file. Please rename it to context.d.ts for type-only definitions.");
-			logger.info("The context file should now be context.d.ts instead of context.ts");
-		}
-	} else logger.info("Scaffold file generation is disabled (library mode)");
 }
 
 //#endregion

package/dist/types/index.d.mts

@@ -1,10 +1,10 @@
 import { StandardSchemaV1 } from "./standard-schema.mjs";
-import { ESMCodeGenOptions } from "knitwork";
-import { IResolvers } from "@graphql-tools/utils";
 import { TypeScriptPluginConfig } from "@graphql-codegen/typescript";
 import { plugin as plugin$1 } from "@graphql-codegen/typescript-generic-sdk";
 import { TypeScriptDocumentsPluginConfig } from "@graphql-codegen/typescript-operations";
+import { IResolvers } from "@graphql-tools/utils";
 import { TypeScriptResolversPluginConfig } from "@graphql-codegen/typescript-resolvers";
+import { ESMCodeGenOptions } from "knitwork";
 
 //#region src/types/index.d.ts
 type CodegenServerConfig = TypeScriptPluginConfig & TypeScriptResolversPluginConfig;

package/dist/utils/client-codegen.d.mts

@@ -1,7 +1,7 @@
 import { CodegenClientConfig, ExternalGraphQLService, GenericSdkConfig } from "../types/index.mjs";
 import { GraphQLSchema } from "graphql";
-import { Source } from "@graphql-tools/utils";
 import { LoadSchemaOptions, UnnormalizedTypeDefPointer } from "@graphql-tools/load";
+import { Source } from "@graphql-tools/utils";
 
 //#region src/utils/client-codegen.d.ts
 

package/dist/utils/client-codegen.mjs

@@ -1,9 +1,10 @@
+import { DEFAULT_GRAPHQL_SCALARS } from "../constants/scalars.mjs";
+import { pluginContent } from "./codegen-plugin.mjs";
 import { defu as defu$1 } from "defu";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { consola as consola$1 } from "consola";
 import { dirname, resolve } from "pathe";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { parse } from "graphql";
-import { printSchemaWithDirectives } from "@graphql-tools/utils";
 import { createHash } from "node:crypto";
 import { codegen } from "@graphql-codegen/core";
 import { preset } from "@graphql-codegen/import-types-preset";
@@ -13,21 +14,9 @@ import { plugin as plugin$2 } from "@graphql-codegen/typescript-operations";
 import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
 import { loadDocuments, loadSchemaSync } from "@graphql-tools/load";
 import { UrlLoader } from "@graphql-tools/url-loader";
-import { CurrencyResolver, DateTimeISOResolver, DateTimeResolver, JSONObjectResolver, JSONResolver, NonEmptyStringResolver, UUIDResolver } from "graphql-scalars";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
 
 //#region src/utils/client-codegen.ts
-function pluginContent(_schema, _documents, _config, _info) {
-	return {
-		prepend: [
-			"// THIS FILE IS GENERATED, DO NOT EDIT!",
-			"/* eslint-disable eslint-comments/no-unlimited-disable */",
-			"/* tslint:disable */",
-			"/* eslint-disable */",
-			"/* prettier-ignore */"
-		],
-		content: ""
-	};
-}
 async function graphQLLoadSchemaSync(schemaPointers, data = {}) {
 	const filteredPointers = [...Array.isArray(schemaPointers) ? schemaPointers : [schemaPointers], "!**/vfs/**"];
 	let result;
@@ -182,19 +171,7 @@ async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, ou
 		pureMagicComment: true,
 		dedupeOperationSuffix: true,
 		rawRequest: true,
-		scalars: {
-			DateTime: DateTimeResolver.extensions.codegenScalarType,
-			DateTimeISO: DateTimeISOResolver.extensions.codegenScalarType,
-			UUID: UUIDResolver.extensions.codegenScalarType,
-			JSON: JSONResolver.extensions.codegenScalarType,
-			JSONObject: JSONObjectResolver.extensions.codegenScalarType,
-			NonEmptyString: NonEmptyStringResolver.extensions.codegenScalarType,
-			Currency: CurrencyResolver.extensions.codegenScalarType,
-			File: {
-				input: "File",
-				output: "File"
-			}
-		}
+		scalars: DEFAULT_GRAPHQL_SCALARS
 	}, config);
 	const mergedSdkConfig = defu$1(mergedConfig, sdkConfig);
 	try {

package/dist/utils/codegen-plugin.d.mts

@@ -0,0 +1,20 @@
+import { GraphQLSchema } from "graphql";
+import { Source } from "@graphql-tools/utils";
+
+//#region src/utils/codegen-plugin.d.ts
+
+/**
+ * Plugin to add prepend comments to generated files
+ * Used by both server and client codegen
+ */
+declare function pluginContent(_schema: GraphQLSchema, _documents: Source[], _config: Record<string, unknown> | undefined, _info: Record<string, unknown> | undefined): {
+  prepend: string[];
+  content: string;
+};
+/**
+ * Generate the prepend header for generated files
+ * Can be used when creating files manually without codegen
+ */
+declare const GENERATED_FILE_HEADER = "// THIS FILE IS GENERATED, DO NOT EDIT!\n/* eslint-disable eslint-comments/no-unlimited-disable */\n/* tslint:disable */\n/* eslint-disable */\n/* prettier-ignore */\n";
+//#endregion
+export { GENERATED_FILE_HEADER, pluginContent };

package/dist/utils/codegen-plugin.mjs

@@ -0,0 +1,30 @@
+//#region src/utils/codegen-plugin.ts
+/**
+* Plugin to add prepend comments to generated files
+* Used by both server and client codegen
+*/
+function pluginContent(_schema, _documents, _config, _info) {
+	return {
+		prepend: [
+			"// THIS FILE IS GENERATED, DO NOT EDIT!",
+			"/* eslint-disable eslint-comments/no-unlimited-disable */",
+			"/* tslint:disable */",
+			"/* eslint-disable */",
+			"/* prettier-ignore */"
+		],
+		content: ""
+	};
+}
+/**
+* Generate the prepend header for generated files
+* Can be used when creating files manually without codegen
+*/
+const GENERATED_FILE_HEADER = `// THIS FILE IS GENERATED, DO NOT EDIT!
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+`;
+
+//#endregion
+export { GENERATED_FILE_HEADER, pluginContent };

package/dist/utils/directive-parser.d.mts

@@ -70,8 +70,9 @@ declare class DirectiveParser {
 declare function generateDirectiveSchema(directive: ParsedDirective): string;
 /**
  * Generate directive schemas file from scanned directives
+ * @returns The path to the generated _directives.graphql file, or null if no directives
  */
-declare function generateDirectiveSchemas(nitro: any, directives: any[]): Promise<void>;
+declare function generateDirectiveSchemas(nitro: any, directives: any[]): Promise<string | null>;
 /**
  * Singleton instance for reuse
  */