feat: update ESLint rules, enhance package exports, and improve client and GraphQL watchers with dynamic imports

Author: productdevbook

eslint.config.mjs

@@ -18,6 +18,7 @@ export default antfu({
 }, {
   rules: {
     'node/prefer-global/process': 'off',
+    'no-new-func': 'off',
   },
 }, {
   files: ['playground/**/*.{ts,js,mjs,cjs}'],

package.json

@@ -8,6 +8,26 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./codegen": {
+      "types": "./dist/codegen.d.ts",
+      "import": "./dist/codegen.js"
+    },
+    "./watcher": {
+      "types": "./dist/watcher.d.ts",
+      "import": "./dist/watcher.js"
+    },
+    "./client-watcher": {
+      "types": "./dist/client-watcher.d.ts",
+      "import": "./dist/client-watcher.js"
+    },
+    "./context": {
+      "types": "./dist/context.d.ts",
+      "import": "./dist/context.js"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "import": "./dist/utils.js"
     }
   },
   "main": "./dist/index.js",

src/client-watcher.ts

@@ -5,21 +5,23 @@ import { mergeTypeDefs } from '@graphql-tools/merge'
 import { makeExecutableSchema } from '@graphql-tools/schema'
 import { consola } from 'consola'
 import { join } from 'pathe'
-import { generateClientTypes } from './client-codegen'
+// import { generateClientTypes } from './client-codegen' // Conditionally imported to prevent bundling
 import { scanGraphQLFiles } from './scanner'
 import { debounce } from './utils'
 
+const logger = consola.withTag('graphql')
+
 async function regenerateClientTypes(nitro: Nitro, options: NitroGraphQLYogaOptions) {
   try {
     if (!options.client?.enabled)
       return
 
-    consola.start('[graphql] 🔄 Regenerating client types...')
+    // Regenerating client types silently
 
     // Get the server schema
     const scanResult = await scanGraphQLFiles(nitro)
     if (scanResult.typeDefs.length === 0) {
-      consola.warn('[graphql] ⚠️  No server schema found for client type generation')
+      logger.warn('⚠️  No server schema found for client type generation')
       return
     }
 
@@ -37,7 +39,8 @@ async function regenerateClientTypes(nitro: Nitro, options: NitroGraphQLYogaOpti
       `!${join(nitro.options.srcDir, 'graphql/**/*')}`,
     ]
 
-    // Generate client types
+    // Generate client types using dynamic import
+    const { generateClientTypes } = await import('./client-codegen')
     const generatedTypes = await generateClientTypes(
       schema,
       clientPatterns,
@@ -53,22 +56,22 @@ async function regenerateClientTypes(nitro: Nitro, options: NitroGraphQLYogaOpti
       await mkdir(typesDir, { recursive: true })
       await writeFile(outputPath, generatedTypes)
 
-      consola.success('[graphql] ✨ Client types updated at:', outputPath)
+      logger.success('✨ Client types updated')
     }
   }
   catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error)
-    consola.error('[graphql] ❌ Client type generation failed:', errorMessage)
+    logger.error('❌ Client type generation failed:', errorMessage)
   }
 }
 
 export async function setupClientWatcher(nitro: Nitro, options: NitroGraphQLYogaOptions) {
   if (!options.client?.enabled) {
-    consola.info('[graphql] 🚫 Client type generation disabled')
+    logger.info('🚫 Client type generation disabled')
     return
   }
 
-  consola.info('[graphql] 🔧 Setting up client file watcher...')
+  // Setting up client file watcher
 
   // Client GraphQL patterns
   const clientPatterns = options.client.watchPatterns || [
@@ -89,12 +92,7 @@ export async function setupClientWatcher(nitro: Nitro, options: NitroGraphQLYoga
     ignore: [join(nitro.options.srcDir, 'graphql/**/*')], // Exclude server files
   })
 
-  if (existingClientFiles.length > 0) {
-    consola.info(`[graphql] 📁 Watching ${existingClientFiles.length} client GraphQL files`)
-  }
-  else {
-    consola.info('[graphql] 📁 No client GraphQL files found to watch')
-  }
+  // Client file watching setup complete
 
   const watchPatterns = existingClientFiles.length > 0 ? existingClientFiles : clientPatterns
 
@@ -109,40 +107,30 @@ export async function setupClientWatcher(nitro: Nitro, options: NitroGraphQLYoga
     binaryInterval: 1000,
   })
 
-  watcher.on('ready', () => {
-    consola.ready('[graphql] 👁️  Client watcher ready')
-  })
-
-  watcher.on('change', (path) => {
-    const fileName = path.split('/').pop()
-    consola.info(`[graphql] 📝 Client file changed: ${fileName}`)
+  watcher.on('change', (_path) => {
     generateClientTypesDebounced()
   })
 
-  watcher.on('add', (path) => {
-    const fileName = path.split('/').pop()
-    consola.info(`[graphql] ➕ Client file added: ${fileName}`)
+  watcher.on('add', (_path) => {
     generateClientTypesDebounced()
   })
 
-  watcher.on('unlink', (path) => {
-    const fileName = path.split('/').pop()
-    consola.info(`[graphql] ➖ Client file removed: ${fileName}`)
+  watcher.on('unlink', (_path) => {
     generateClientTypesDebounced()
   })
 
   watcher.on('error', (error) => {
     const errorMessage = error instanceof Error ? error.message : String(error)
-    consola.error('[graphql] ❌ Client watcher error:', errorMessage)
+    logger.error('❌ Client watcher error:', errorMessage)
   })
 
   nitro.hooks.hook('close', () => {
-    consola.info('[graphql] 🔒 Closing client watcher')
+    logger.info('🔒 Closing client watcher')
     watcher.close()
   })
 
   // Generate initial types
   await generateClientTypesDebounced()
 
-  consola.success('[graphql] ✅ Client watcher ready')
+  logger.success('✅ Client watcher ready')
 }

src/index.ts

@@ -6,10 +6,10 @@ import { makeExecutableSchema } from '@graphql-tools/schema'
 import { consola } from 'consola'
 import { defineNitroModule } from 'nitropack/kit'
 import { join } from 'pathe'
-import { setupClientWatcher } from './client-watcher'
-import { generateTypes } from './codegen'
+// import { generateTypes } from './codegen' // Conditionally imported to prevent bundling
 import { scanGraphQLFiles } from './scanner'
-import { setupGraphQLWatcher } from './watcher'
+
+const logger = consola.withTag('graphql')
 
 export default defineNitroModule({
   name: 'nitro:graphql-yoga',
@@ -44,6 +44,31 @@ export default defineNitroModule({
 
     // Access the internal rollup config and add our prefix
     nitro.hooks.hook('rollup:before', (nitro, rollupConfig) => {
+      // Add codegen packages as external dependencies to prevent bundling
+      rollupConfig.external = rollupConfig.external || []
+      const codegenExternals = [
+        '@graphql-codegen/core',
+        '@graphql-codegen/typescript',
+        '@graphql-codegen/typescript-resolvers',
+        '@graphql-codegen/typescript-operations',
+        '@graphql-codegen/typescript-generic-sdk',
+        '@graphql-tools/graphql-file-loader',
+        '@graphql-tools/load',
+      ]
+
+      if (Array.isArray(rollupConfig.external)) {
+        rollupConfig.external.push(...codegenExternals)
+      }
+      else if (typeof rollupConfig.external === 'function') {
+        const originalExternal = rollupConfig.external
+        rollupConfig.external = (id, parent, isResolved) => {
+          if (codegenExternals.some(external => id.includes(external))) {
+            return true
+          }
+          return originalExternal(id, parent, isResolved)
+        }
+      }
+
       // Add GraphQL path to chunkNamePrefixes
       const originalChunkFileNames = rollupConfig.output.chunkFileNames
       rollupConfig.output.chunkFileNames = (chunk) => {
@@ -82,24 +107,19 @@ export type { GraphQLContext } from 'nitro-graphql-yoga/context'
 
     // Log resolver discovery for debugging
     if (scanResult.resolvers.length > 0) {
-      consola.success(`[graphql] Found ${scanResult.resolvers.length} resolvers`)
-
-      if (nitro.options.dev) {
-        consola.info('[graphql] Resolver files:')
-        for (const resolver of scanResult.resolvers) {
-          consola.info(`  ${resolver.name} -> ${resolver.relativePath}`)
-        }
-      }
+      logger.success(`Found ${scanResult.resolvers.length} resolvers`)
     }
 
-    // Generate initial types if we have GraphQL files
+    // Generate types for both development and build modes
     if (scanResult.typeDefs.length > 0) {
       const mergedTypeDefs = mergeTypeDefs(scanResult.typeDefs)
       const schema = makeExecutableSchema({
         typeDefs: mergedTypeDefs,
         resolvers: {},
       })
 
+      // Use Function constructor to prevent bundling in production
+      const { generateTypes } = await (new Function('return import("nitro-graphql-yoga/codegen")'))()
       const generatedTypes = await generateTypes(schema)
 
       // Write to file
@@ -119,11 +139,37 @@ declare module 'nitro-graphql-yoga' {
 `
       await writeFile(graphqlDtsPath, graphqlDtsContent)
 
-      consola.success('[graphql] Generated types at:', outputPath)
+      logger.success('Types generated')
+    }
+    else {
+      // Create minimal types when no schema files found
+      const typesDir = join(nitro.options.buildDir, 'types')
+      await mkdir(typesDir, { recursive: true })
+
+      const minimalTypes = `// Generated by nitro-graphql-yoga (no schema found)
+export type Resolvers = any
+`
+      const outputPath = join(typesDir, 'graphql-types.generated.ts')
+      await writeFile(outputPath, minimalTypes)
+
+      const graphqlDtsPath = join(typesDir, 'graphql.d.ts')
+      const graphqlDtsContent = `// Auto-generated by nitro-graphql-yoga
+import type { Resolvers as Test } from './graphql-types.generated'
+
+declare module 'nitro-graphql-yoga' {
+  interface Resolvers extends Test {}
+}
+`
+      await writeFile(graphqlDtsPath, graphqlDtsContent)
+
+      logger.info('Created minimal types (no schema found)')
     }
 
-    // Setup file watchers in dev mode
+    // Setup file watchers in dev mode - completely excluded from production
     if (nitro.options.dev) {
+      // Use Function constructor to prevent bundling in production
+      const setupGraphQLWatcher = (await (new Function('return import("nitro-graphql-yoga/watcher")'))()).setupGraphQLWatcher
+      const setupClientWatcher = (await (new Function('return import("nitro-graphql-yoga/client-watcher")'))()).setupClientWatcher
       await setupGraphQLWatcher(nitro)
       await setupClientWatcher(nitro, options)
     }
@@ -165,7 +211,6 @@ import { defineEventHandler, readRawBody, setHeader, setResponseStatus } from 'h
 import { useStorage } from 'nitro/runtime'
 import { makeExecutableSchema } from '@graphql-tools/schema'
 import { mergeTypeDefs, mergeResolvers } from '@graphql-tools/merge'
-import { loadFilesSync } from '@graphql-tools/load-files'
 import { join } from 'pathe'
 // Types are generated at build time to .nitro/graphql-types.generated.ts
 
@@ -204,26 +249,24 @@ async function loadResolvers() {
           
           if (resolver) {
             resolverModules.push(resolver)
-            console.log('[nitro-graphql-yoga] Loaded resolver:', i)
           }
         } catch (error) {
-          console.warn('[nitro-graphql-yoga] Failed to load resolver:', i, error.message)
+          console.warn('[graphql] Failed to load resolver:', i, error.message)
         }
       }
       
       if (resolverModules.length > 0) {
         resolvers = mergeResolvers(resolverModules)
-        console.log('[nitro-graphql-yoga] Successfully merged', resolverModules.length, 'resolvers')
       } else {
-        console.warn('[nitro-graphql-yoga] No resolvers could be loaded')
+        console.warn('[graphql] No resolvers could be loaded')
         resolvers = { Query: {}, Mutation: {} }
       }
     } else {
-      console.warn('[nitro-graphql-yoga] No resolvers found')
+      console.warn('[graphql] No resolvers found')
       resolvers = { Query: {}, Mutation: {} }
     }
   } catch (error) {
-    console.warn('[nitro-graphql-yoga] Error loading resolvers:', error.message)
+    console.warn('[graphql] Error loading resolvers:', error.message)
     resolvers = { Query: {}, Mutation: {} }
   }
   return resolvers