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

package/dist/setup/scaffold-generator.mjs

@@ -0,0 +1,109 @@
+import { FILE_CONFIG_TS, FILE_CONTEXT_DTS, FILE_CONTEXT_TS, FILE_GRAPHQL_CONFIG, FILE_SCHEMA_TS, LOG_TAG } from "../constants.mjs";
+import { relativeWithDot } from "../utils/index.mjs";
+import { writeFileIfNotExists } from "../utils/file-generator.mjs";
+import { getDefaultPaths, getScaffoldConfig, resolveFilePath, shouldGenerateScaffold } from "../utils/path-resolver.mjs";
+import consola from "consola";
+import { join, resolve } from "pathe";
+import { existsSync, mkdirSync } from "node:fs";
+
+//#region src/setup/scaffold-generator.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Generate all scaffold files based on configuration
+* Can be disabled via: scaffold: false or scaffold.enabled: false
+*/
+function generateScaffoldFiles(nitro) {
+	if (!shouldGenerateScaffold(nitro)) {
+		logger.info("Scaffold file generation is disabled (library mode)");
+		return;
+	}
+	const placeholders = getDefaultPaths(nitro);
+	const scaffoldConfig = getScaffoldConfig(nitro);
+	generateGraphQLConfig(nitro, scaffoldConfig, placeholders);
+	generateServerScaffoldFiles(nitro, scaffoldConfig, placeholders);
+	checkOldContextFile(nitro);
+}
+/**
+* Generate graphql.config.ts for IDE tooling support
+*/
+function generateGraphQLConfig(nitro, scaffoldConfig, placeholders) {
+	const graphqlConfigPath = resolveFilePath(scaffoldConfig.graphqlConfig, scaffoldConfig.enabled, true, FILE_GRAPHQL_CONFIG, placeholders);
+	if (!graphqlConfigPath) return;
+	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}"))}',
+        ],
+      },
+    },
+}`, FILE_GRAPHQL_CONFIG);
+}
+/**
+* Generate server-side scaffold files (schema.ts, config.ts, context.d.ts)
+*/
+function generateServerScaffoldFiles(nitro, scaffoldConfig, placeholders) {
+	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 ${FILE_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 ${FILE_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 ${FILE_CONTEXT_DTS}`);
+}
+/**
+* Check for old context.ts file and warn users to migrate to context.d.ts
+*/
+function checkOldContextFile(nitro) {
+	if (existsSync(join(nitro.graphql.serverDir, FILE_CONTEXT_TS))) {
+		logger.warn(`Found ${FILE_CONTEXT_TS} file. Please rename it to ${FILE_CONTEXT_DTS} for type-only definitions.`);
+		logger.info(`The context file should now be ${FILE_CONTEXT_DTS} instead of ${FILE_CONTEXT_TS}`);
+	}
+}
+
+//#endregion
+export { generateScaffoldFiles };

package/dist/setup/ts-config.mjs

@@ -0,0 +1,69 @@
+import { relativeWithDot } from "../utils/index.mjs";
+import { getDefaultPaths, getTypesConfig, resolveFilePath } from "../utils/path-resolver.mjs";
+import { dirname, join, resolve } from "pathe";
+
+//#region src/setup/ts-config.ts
+/**
+* Setup TypeScript path aliases for GraphQL types
+* Called via nitro:config hook to extend tsconfig.json
+*/
+function setupTypeScriptPaths(nitro, types) {
+	const tsconfigDir = dirname(resolve(nitro.options.buildDir, nitro.options.typescript.tsconfigPath));
+	types.tsConfig ||= {};
+	types.tsConfig.compilerOptions ??= {};
+	types.tsConfig.compilerOptions.paths ??= {};
+	types.tsConfig.include = types.tsConfig.include || [];
+	const placeholders = getDefaultPaths(nitro);
+	const typesConfig = getTypesConfig(nitro);
+	setupServerTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig);
+	setupClientTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig);
+	setupSchemaPath(nitro, types, tsconfigDir);
+	setupExternalServicePaths(nitro, types, tsconfigDir, placeholders, typesConfig);
+	types.tsConfig.include.push(relativeWithDot(tsconfigDir, join(placeholders.typesDir, "graphql.d.ts")));
+}
+/**
+* Setup #graphql/server path alias
+*/
+function setupServerTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig) {
+	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)];
+		types.tsConfig.include.push(relativeWithDot(tsconfigDir, serverTypesPath));
+	}
+}
+/**
+* Setup #graphql/client path alias
+*/
+function setupClientTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig) {
+	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.include.push(relativeWithDot(tsconfigDir, clientTypesPath));
+	}
+}
+/**
+* Setup #graphql/schema path alias
+*/
+function setupSchemaPath(nitro, types, tsconfigDir) {
+	types.tsConfig.compilerOptions.paths["#graphql/schema"] = [relativeWithDot(tsconfigDir, join(nitro.graphql.serverDir, "schema.ts"))];
+}
+/**
+* Setup #graphql/client/{serviceName} path aliases for external services
+*/
+function setupExternalServicePaths(nitro, types, tsconfigDir, placeholders, typesConfig) {
+	if (!nitro.options.graphql?.externalServices?.length) return;
+	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.push(relativeWithDot(tsconfigDir, externalTypesPath));
+		}
+	}
+}
+
+//#endregion
+export { setupTypeScriptPaths };

package/dist/setup.d.mts

@@ -3,8 +3,8 @@ import { Nitro } from "nitro/types";
 //#region src/setup.d.ts
 
 /**
- * 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
  */
 declare function setupNitroGraphQL(nitro: Nitro): Promise<void>;
 //#endregion

package/dist/setup.mjs

@@ -1,40 +1,50 @@
+import { ENDPOINT_DEBUG, FRAMEWORK_NITRO, FRAMEWORK_NUXT, GRAPHQL_HTTP_METHODS, LOG_TAG } from "./constants.mjs";
+import { DEFAULT_RUNTIME_CONFIG, DEFAULT_TYPESCRIPT_STRICT, DEFAULT_TYPES_CONFIG } from "./config/defaults.mjs";
 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 { scanDirectives, scanDocuments, scanResolvers, scanSchemas, validateExternalServices } from "./utils/index.mjs";
+import { getDefaultPaths } from "./utils/path-resolver.mjs";
+import { clientTypeGeneration, serverTypeGeneration } from "./codegen/index.mjs";
 import { rollupConfig } from "./rollup.mjs";
+import { getWatchDirectories, setupFileWatcher } from "./setup/file-watcher.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,100 +57,87 @@ 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);
+}
+/**
+* Scan all GraphQL files (schemas, resolvers, directives, documents)
+*/
+async function scanGraphQLFiles(nitro) {
 	const directives = await scanDirectives(nitro);
 	nitro.scanDirectives = directives;
-	await generateDirectiveSchemas(nitro, directives);
+	nitro.scanSchemas = [];
+	const directivesPath = await generateDirectiveSchemas(nitro, directives);
+	const schemas = await scanSchemas(nitro);
+	if (directivesPath && !schemas.includes(directivesPath)) schemas.push(directivesPath);
+	nitro.scanSchemas = schemas;
+	nitro.scanDocuments = await scanDocuments(nitro);
+	nitro.scanResolvers = await scanResolvers(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 directives = await scanDirectives(nitro);
+		nitro.scanDirectives = directives;
+		if (!nitro.scanSchemas) nitro.scanSchemas = [];
+		const directivesPath = await generateDirectiveSchemas(nitro, directives);
+		const schemas = await scanSchemas(nitro);
+		if (directivesPath && !schemas.includes(directivesPath)) schemas.push(directivesPath);
+		nitro.scanSchemas = schemas;
+		nitro.scanDocuments = await scanDocuments(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);
 		if (nitro.options.dev && !hasShownInitialLogs) {
 			hasShownInitialLogs = true;
 			if (resolvers.length > 0) {
@@ -165,25 +162,35 @@ async function setupNitroGraphQL(nitro) {
 			} else logger.warn("No resolvers found. Check /_nitro/graphql/debug for details.");
 		}
 	});
-	await rollupConfig(nitro);
+}
+/**
+* Generate server and client types
+*/
+async function generateTypes(nitro) {
 	await serverTypeGeneration(nitro);
 	await clientTypeGeneration(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 });
 	});
+}
+/**
+* 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 +201,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