feat: enhance GraphQL directive schema generation and file watching

Author: productdevbook

src/core/scanning/common.ts

@@ -8,6 +8,16 @@ import { join, relative } from 'pathe'
 import { glob } from 'tinyglobby'
 import { GLOB_SCAN_PATTERN } from '../constants'
 
+// Default patterns to always ignore during scanning
+const DEFAULT_IGNORE_PATTERNS = [
+  '**/node_modules/**',
+  '**/.git/**',
+  '**/.output/**',
+  '**/.nitro/**',
+  '**/.nuxt/**',
+  '**/.graphql/**',
+]
+
 /**
  * Scan a directory for files matching a glob pattern
  */
@@ -20,7 +30,7 @@ export async function scanDirectory(
   const fileNames = await glob(join(subDir, globPattern), {
     cwd: baseDir,
     dot: true,
-    ignore: ctx.ignorePatterns,
+    ignore: [...DEFAULT_IGNORE_PATTERNS, ...ctx.ignorePatterns],
     absolute: true,
   }).catch((error) => {
     if ((error as NodeJS.ErrnoException)?.code === 'ENOTDIR') {

src/core/utils/directive-parser.ts

@@ -288,11 +288,12 @@ function getFilePath(ref: DirectiveFileRef): string {
 export const directiveParser = new DirectiveParser()
 
 /**
- * Generate GraphQL schemas from an array of parsed directives
+ * Generate GraphQL schema content from an array of parsed directives
+ * Returns the schema string and optionally writes to buildDir/directives.graphql
  */
 export async function generateDirectiveSchemas(
-  nitro: { graphql: { buildDir: string } },
   directives: DirectiveFileRef[],
+  buildDir?: string,
 ): Promise<string | null> {
   if (directives.length === 0) {
     return null
@@ -323,16 +324,19 @@ export async function generateDirectiveSchemas(
     .map(d => generateDirectiveSchema(d))
     .join('\n\n')
 
-  const directivesPath = path.join(nitro.graphql.buildDir, '_directives.graphql')
-  fs.mkdirSync(path.dirname(directivesPath), { recursive: true })
+  // Write to .graphql/directives.graphql if buildDir provided
+  if (buildDir) {
+    const directivesPath = path.join(buildDir, 'directives.graphql')
+    fs.mkdirSync(buildDir, { recursive: true })
 
-  // Only write if content changed to prevent unnecessary file watcher triggers
-  const existingContent = fs.existsSync(directivesPath)
-    ? fs.readFileSync(directivesPath, 'utf-8')
-    : null
-  if (existingContent !== schemaContent) {
-    fs.writeFileSync(directivesPath, schemaContent, 'utf-8')
+    // Only write if content changed
+    const existingContent = fs.existsSync(directivesPath)
+      ? fs.readFileSync(directivesPath, 'utf-8')
+      : null
+    if (existingContent !== schemaContent) {
+      fs.writeFileSync(directivesPath, schemaContent, 'utf-8')
+    }
   }
 
-  return directivesPath
+  return schemaContent
 }

src/nitro/codegen.ts

@@ -72,6 +72,13 @@ export async function generateServerTypes(
       }
     })
 
+    // Add inline directive schemas (generated from .directive.ts files)
+    const directiveSchemas = nitro.graphql.directiveSchemas
+    if (directiveSchemas) {
+      validSchemas.push('<directives>')
+      strings.push(directiveSchemas)
+    }
+
     if (!validateNoDuplicateTypes(validSchemas, strings))
       return
 

src/nitro/setup.ts

@@ -136,6 +136,7 @@ function initializeConfiguration(nitro: Nitro, serverEnabled: boolean): void {
       client: 'graphql',
       server: 'server',
     },
+    directiveSchemas: null,
   }
 
   // Initialize empty arrays for server-related scans (needed even if server disabled)
@@ -171,7 +172,8 @@ function validateConfiguration(nitro: Nitro): void {
  * Setup build directories
  */
 function setupBuildDirectories(nitro: Nitro): void {
-  const graphqlBuildDir = resolve(nitro.options.buildDir, 'graphql')
+  // Use .graphql/ in root directory instead of .nitro/graphql/
+  const graphqlBuildDir = resolve(nitro.options.rootDir, '.graphql')
   nitro.graphql.buildDir = graphqlBuildDir
 
   // Update relative dir paths based on framework

src/nitro/setup/file-watcher.ts

@@ -60,10 +60,29 @@ interface PendingChanges {
  * Watches for changes and triggers type regeneration and dev server reload
  */
 export function setupFileWatcher(nitro: Nitro, watchDirs: string[]): FSWatcher {
+  // Only watch graphql-related files, ignore everything else
+  const ignored = (path: string) => {
+    // Always ignore these directories
+    if (path.includes('/node_modules/') || path.includes('/.git/')
+      || path.includes('/.output/') || path.includes('/.nitro/')
+      || path.includes('/.nuxt/') || path.includes('/.graphql/')) {
+      return true
+    }
+    // Check if it's a directory (no extension or ends with /) - allow traversal
+    if (!path.includes('.') || path.endsWith('/')) {
+      return false
+    }
+    // Only watch graphql, resolver, and directive files
+    const isGraphQL = GRAPHQL_EXTENSIONS.some(ext => path.endsWith(ext))
+    const isResolver = RESOLVER_EXTENSIONS.some(ext => path.endsWith(ext))
+    const isDirective = DIRECTIVE_EXTENSIONS.some(ext => path.endsWith(ext))
+    return !isGraphQL && !isResolver && !isDirective
+  }
+
   const watcher = watch(watchDirs, {
     persistent: DEFAULT_WATCHER_PERSISTENT,
     ignoreInitial: DEFAULT_WATCHER_IGNORE_INITIAL,
-    ignored: nitro.options.ignore,
+    ignored,
   })
 
   const pending: PendingChanges = { server: false, client: false, graphql: false }
@@ -76,17 +95,12 @@ export function setupFileWatcher(nitro: Nitro, watchDirs: string[]): FSWatcher {
       const directivesResult = await NitroAdapter.scanDirectives(nitro)
       nitro.scanDirectives = directivesResult.items
 
-      if (!nitro.scanSchemas)
-        nitro.scanSchemas = []
+      // Generate directive schemas and write to .graphql/directives.graphql
+      const directiveSchemas = await generateDirectiveSchemas(directivesResult.items, nitro.graphql.buildDir)
+      nitro.graphql.directiveSchemas = directiveSchemas
 
-      const directivesPath = await generateDirectiveSchemas(nitro, directivesResult.items)
       const schemasResult = await NitroAdapter.scanSchemas(nitro)
-      const schemas = schemasResult.items
-
-      if (directivesPath && !schemas.includes(directivesPath))
-        schemas.push(directivesPath)
-
-      nitro.scanSchemas = schemas
+      nitro.scanSchemas = schemasResult.items
       nitro.scanResolvers = (await NitroAdapter.scanResolvers(nitro)).items
 
       await resolveExtendConfig(nitro, { silent: true })

src/nitro/setup/scanner.ts

@@ -64,17 +64,13 @@ export async function scanLocalFiles(nitro: Nitro): Promise<ScanResult> {
   const directivesResult = await NitroAdapter.scanDirectives(nitro)
   nitro.scanDirectives = directivesResult.items
 
-  // Generate _directives.graphql file
-  if (!nitro.scanSchemas)
-    nitro.scanSchemas = []
-  const directivesPath = await generateDirectiveSchemas(nitro, directivesResult.items)
+  // Generate directive schemas and write to .graphql/directives.graphql
+  const directiveSchemas = await generateDirectiveSchemas(directivesResult.items, nitro.graphql.buildDir)
+  nitro.graphql.directiveSchemas = directiveSchemas
 
   // Scan schemas
   const schemasResult = await NitroAdapter.scanSchemas(nitro)
-  const schemas = schemasResult.items
-  if (directivesPath && !schemas.includes(directivesPath))
-    schemas.push(directivesPath)
-  nitro.scanSchemas = schemas
+  nitro.scanSchemas = schemasResult.items
 
   // Scan documents and resolvers
   const docsResult = await NitroAdapter.scanDocuments(nitro)
@@ -84,7 +80,7 @@ export async function scanLocalFiles(nitro: Nitro): Promise<ScanResult> {
   nitro.scanResolvers = resolversResult.items
 
   return {
-    schemas: schemas.length,
+    schemas: schemasResult.items.length,
     resolvers: resolversResult.items.length,
     directives: directivesResult.items.length,
     documents: docsResult.items.length,

src/nitro/types.ts

@@ -279,6 +279,8 @@ declare module 'nitro/types' {
         client: string
         server: string
       }
+      /** Inline directive schemas generated from .directive.ts files */
+      directiveSchemas: string | null
       /** Resolved extend paths from manifests (populated during setup) */
       resolvedExtend?: {
         schemas: string[]

src/nitro/virtual/generators.ts

@@ -48,8 +48,9 @@ export const serverSchemas = {
   getCode: (nitro: Nitro): string => {
     // All schemas (local + manifest) are now in nitro.scanSchemas
     const schemas = [...nitro.scanSchemas, ...(nitro.options.graphql?.typedefs ?? [])]
+    const directiveSchemas = nitro.graphql.directiveSchemas
 
-    if (!schemas.length) {
+    if (!schemas.length && !directiveSchemas) {
       if (nitro.options.dev) {
         nitro.logger.warn('[nitro-graphql] No schemas found. Virtual module will export empty array.')
       }
@@ -59,6 +60,11 @@ export const serverSchemas = {
     const importStatements = schemas.map(s => `import ${getImportId(s)} from '${s}';`)
     const schemaArray = schemas.map(s => `{ def: ${getImportId(s)} }`)
 
+    // Add inline directive schemas if present
+    if (directiveSchemas) {
+      schemaArray.push(`{ def: ${JSON.stringify(directiveSchemas)} }`)
+    }
+
     return `${importStatements.join('\n')}\n\nexport const schemas = [\n${schemaArray.join(',\n')}\n];`
   },
 }