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

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,198 +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"
 	});
-	if (nitro.options.imports) {
-		nitro.options.imports.presets ??= [];
-		nitro.options.imports.presets.push({
-			from: fileURLToPath(new URL("define", import.meta.url)),
-			imports: [
-				"defineResolver",
-				"defineMutation",
-				"defineQuery",
-				"defineSubscription",
-				"defineType",
-				"defineGraphQLConfig",
-				"defineSchema",
-				"defineDirective"
-			]
-		});
-	}
-	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,9 +1,9 @@
 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";
 
 //#region src/types/index.d.ts

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,8 @@
 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 { parse } from "graphql";
-import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { codegen } from "@graphql-codegen/core";
 import { preset } from "@graphql-codegen/import-types-preset";
@@ -13,9 +12,13 @@ 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 { printSchemaWithDirectives } from "@graphql-tools/utils";
 import { CurrencyResolver, DateTimeISOResolver, DateTimeResolver, JSONObjectResolver, JSONResolver, NonEmptyStringResolver, UUIDResolver } from "graphql-scalars";
 
 //#region src/utils/client-codegen.ts
+/**
+* Plugin to add prepend comments to generated files
+*/
 function pluginContent(_schema, _documents, _config, _info) {
 	return {
 		prepend: [

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
  */

package/dist/utils/directive-parser.mjs

@@ -181,9 +181,10 @@ function generateDirectiveSchema(directive) {
 }
 /**
 * Generate directive schemas file from scanned directives
+* @returns The path to the generated _directives.graphql file, or null if no directives
 */
 async function generateDirectiveSchemas(nitro, directives) {
-	if (directives.length === 0) return;
+	if (directives.length === 0) return null;
 	const { existsSync, readFileSync, writeFileSync, mkdirSync } = await import("node:fs");
 	const { readFile } = await import("node:fs/promises");
 	const { resolve, dirname } = await import("pathe");
@@ -212,8 +213,9 @@ ${directiveSchemas.join("\n\n")}`;
 		let shouldWrite = true;
 		if (existsSync(directivesPath)) shouldWrite = readFileSync(directivesPath, "utf-8") !== content;
 		if (shouldWrite) writeFileSync(directivesPath, content, "utf-8");
-		if (!nitro.scanSchemas.includes(directivesPath)) nitro.scanSchemas.push(directivesPath);
+		return directivesPath;
 	}
+	return null;
 }
 /**
 * Singleton instance for reuse

package/dist/utils/file-generator.mjs

@@ -1,6 +1,6 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import consola from "consola";
 import { dirname } from "pathe";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 
 //#region src/utils/file-generator.ts
 /**

package/dist/utils/index.d.mts

@@ -27,7 +27,7 @@ declare function scanGraphql(nitro: Nitro): Promise<string[]>;
 declare function scanResolvers(nitro: Nitro): Promise<GenImport[]>;
 declare function scanDirectives(nitro: Nitro): Promise<GenImport[]>;
 declare function scanSchemas(nitro: Nitro): Promise<string[]>;
-declare function scanDocs(nitro: Nitro): Promise<string[]>;
+declare function scanDocuments(nitro: Nitro): Promise<string[]>;
 /**
  * Scan documents for a specific external service
  */
@@ -37,4 +37,4 @@ declare function scanExternalServiceDocs(nitro: Nitro, serviceName: string, patt
  */
 declare function validateExternalServices(services: unknown[]): string[];
 //#endregion
-export { GLOB_SCAN_PATTERN, createDefaultMaskError, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, validateExternalServices };
+export { GLOB_SCAN_PATTERN, createDefaultMaskError, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocuments, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, validateExternalServices };