nitro-graphql 2.0.0-beta.25 → 2.0.0-beta.26

package/README.md

@@ -56,12 +56,12 @@
 
 **GraphQL Yoga (recommended):**
 ```bash
-pnpm add nitro-graphql graphql-yoga graphql graphql-config
+pnpm add nitro-graphql@beta graphql-yoga graphql graphql-config
 ```
 
 **Apollo Server:**
 ```bash
-pnpm add nitro-graphql @apollo/server @apollo/utils.withrequired graphql graphql-config
+pnpm add nitro-graphql@beta @apollo/server @apollo/utils.withrequired graphql graphql-config
 ```
 
 ### 2. Configure
@@ -71,13 +71,15 @@ pnpm add nitro-graphql @apollo/server @apollo/utils.withrequired graphql graphql
 
 ```ts
 // nitro.config.ts
+import graphql from 'nitro-graphql'
 import { defineNitroConfig } from 'nitro/config'
 
 export default defineNitroConfig({
-  modules: ['nitro-graphql'],
-  graphql: {
-    framework: 'graphql-yoga', // or 'apollo-server'
-  },
+  modules: [
+    graphql({
+      framework: 'graphql-yoga', // or 'apollo-server'
+    }),
+  ],
 })
 ```
 
@@ -90,18 +92,20 @@ export default defineNitroConfig({
 // vite.config.ts
 import { defineConfig } from 'vite'
 import { nitro } from 'nitro/vite'
-import { graphql } from 'nitro-graphql/vite'
+import graphql from 'nitro-graphql'
+import { graphql as graphqlVite } from 'nitro-graphql/vite'
 
 export default defineConfig({
   plugins: [
-    graphql(), // ⚠️ Must be before nitro()
+    graphqlVite(), // ⚠️ Must be before nitro()
     nitro(),
   ],
   nitro: {
-    modules: ['nitro-graphql'],
-    graphql: {
-      framework: 'graphql-yoga',
-    },
+    modules: [
+      graphql({
+        framework: 'graphql-yoga',
+      }),
+    ],
   },
 })
 ```
@@ -281,12 +285,17 @@ Disable all scaffold files for library/module development:
 
 ```ts
 // nitro.config.ts
+import graphql from 'nitro-graphql'
+import { defineNitroConfig } from 'nitro/config'
+
 export default defineNitroConfig({
-  graphql: {
-    framework: 'graphql-yoga',
-    scaffold: false,        // Disable all scaffold files
-    clientUtils: false,     // Disable client utilities
-  }
+  modules: [
+    graphql({
+      framework: 'graphql-yoga',
+      scaffold: false,        // Disable all scaffold files
+      clientUtils: false,     // Disable client utilities
+    }),
+  ],
 })
 ```
 
@@ -295,37 +304,42 @@ export default defineNitroConfig({
 Control each file individually:
 
 ```ts
+import graphql from 'nitro-graphql'
+import { defineNitroConfig } from 'nitro/config'
+
 export default defineNitroConfig({
-  graphql: {
-    framework: 'graphql-yoga',
-
-    // Scaffold files
-    scaffold: {
-      graphqlConfig: false,     // Don't generate graphql.config.ts
-      serverSchema: true,       // Generate server/graphql/schema.ts
-      serverConfig: true,       // Generate server/graphql/config.ts
-      serverContext: false,     // Don't generate server/graphql/context.ts
-    },
+  modules: [
+    graphql({
+      framework: 'graphql-yoga',
 
-    // Client utilities (Nuxt only)
-    clientUtils: {
-      index: true,              // Generate app/graphql/index.ts
-      ofetch: false,            // Don't generate ofetch wrappers
-    },
+      // Scaffold files
+      scaffold: {
+        graphqlConfig: false,     // Don't generate graphql.config.ts
+        serverSchema: true,       // Generate server/graphql/schema.ts
+        serverConfig: true,       // Generate server/graphql/config.ts
+        serverContext: false,     // Don't generate server/graphql/context.ts
+      },
 
-    // SDK files
-    sdk: {
-      main: true,               // Generate default SDK
-      external: true,           // Generate external service SDKs
-    },
+      // Client utilities (Nuxt only)
+      clientUtils: {
+        index: true,              // Generate app/graphql/index.ts
+        ofetch: false,            // Don't generate ofetch wrappers
+      },
 
-    // Type files
-    types: {
-      server: true,             // Generate server types
-      client: true,             // Generate client types
-      external: true,           // Generate external service types
-    }
-  }
+      // SDK files
+      sdk: {
+        main: true,               // Generate default SDK
+        external: true,           // Generate external service SDKs
+      },
+
+      // Type files
+      types: {
+        server: true,             // Generate server types
+        client: true,             // Generate client types
+        external: true,           // Generate external service types
+      },
+    }),
+  ],
 })
 ```
 
@@ -334,34 +348,39 @@ export default defineNitroConfig({
 Customize where files are generated:
 
 ```ts
+import graphql from 'nitro-graphql'
+import { defineNitroConfig } from 'nitro/config'
+
 export default defineNitroConfig({
-  graphql: {
-    framework: 'graphql-yoga',
-
-    // Method 1: Global paths (affects all files)
-    paths: {
-      serverGraphql: 'src/server/graphql',
-      clientGraphql: 'src/client/graphql',
-      buildDir: '.build',
-      typesDir: '.build/types',
-    },
+  modules: [
+    graphql({
+      framework: 'graphql-yoga',
 
-    // Method 2: Specific file paths
-    scaffold: {
-      serverSchema: 'lib/graphql/schema.ts',
-      serverConfig: 'lib/graphql/config.ts',
-    },
+      // Method 1: Global paths (affects all files)
+      paths: {
+        serverGraphql: 'src/server/graphql',
+        clientGraphql: 'src/client/graphql',
+        buildDir: '.build',
+        typesDir: '.build/types',
+      },
 
-    sdk: {
-      main: 'app/graphql/organization/sdk.ts',
-      external: 'app/graphql/{serviceName}/client-sdk.ts',
-    },
+      // Method 2: Specific file paths
+      scaffold: {
+        serverSchema: 'lib/graphql/schema.ts',
+        serverConfig: 'lib/graphql/config.ts',
+      },
 
-    types: {
-      server: 'types/graphql-server.d.ts',
-      client: 'types/graphql-client.d.ts',
-    }
-  }
+      sdk: {
+        main: 'app/graphql/organization/sdk.ts',
+        external: 'app/graphql/{serviceName}/client-sdk.ts',
+      },
+
+      types: {
+        server: 'types/graphql-server.d.ts',
+        client: 'types/graphql-client.d.ts',
+      },
+    }),
+  ],
 })
 ```
 
@@ -576,14 +595,19 @@ Build federated GraphQL services:
 
 ```ts
 // nitro.config.ts
+import graphql from 'nitro-graphql'
+import { defineNitroConfig } from 'nitro/config'
+
 export default defineNitroConfig({
-  graphql: {
-    framework: 'apollo-server',
-    federation: {
-      enabled: true,
-      serviceName: 'users-service'
-    }
-  }
+  modules: [
+    graphql({
+      framework: 'apollo-server',
+      federation: {
+        enabled: true,
+        serviceName: 'users-service',
+      },
+    }),
+  ],
 })
 ```
 
@@ -773,463 +797,6 @@ This package powers production applications:
 
 - [**Nitroping**](https://github.com/productdevbook/nitroping) - Self-hosted push notification service
 
-## 🤖 Using Claude Code
-
-Speed up development with [Claude Code](https://claude.ai/code) — AI-powered assistance for setting up and building with nitro-graphql.
-
-### Quick Setup Prompts
-
-Copy and paste these prompts into Claude Code to scaffold a complete GraphQL API.
-
-**💡 Tip**: After pasting, Claude Code will execute step-by-step and validate each action.
-
-<details>
-<summary>🟢 <strong>Nuxt Project</strong></summary>
-
-```
-## GOAL
-Set up nitro-graphql in this Nuxt project with a User management GraphQL API.
-
-## PREREQUISITES
-Check if this is a Nuxt project by looking for nuxt.config.ts in the root.
-
-## STEP 1: INSTALL DEPENDENCIES
-Action: Run this command
-Command: pnpm add nitro-graphql graphql-yoga graphql
-Validation: Check package.json contains these packages
-
-## STEP 2: CONFIGURE NUXT
-File: nuxt.config.ts
-Action: EDIT (add to existing config, don't replace)
-Add these properties:
-
-export default defineNuxtConfig({
-  modules: ['nitro-graphql/nuxt'],  // Add this module
-  nitro: {
-    graphql: {
-      framework: 'graphql-yoga',
-    },
-  },
-})
-
-Validation: Check the file has modules array and nitro.graphql config
-
-## STEP 3: CREATE SCHEMA
-File: server/graphql/schema.graphql
-Action: CREATE NEW FILE (create server/graphql/ directory if needed)
-Content:
-
-type User {
-  id: ID!
-  name: String!
-  email: String!
-}
-
-type Query {
-  users: [User!]!
-  user(id: ID!): User
-}
-
-type Mutation {
-  _empty: String
-}
-
-Validation: File should be in server/graphql/ directory
-
-## STEP 4: CREATE CONTEXT (Optional but recommended)
-File: server/graphql/context.ts
-Action: CREATE NEW FILE (auto-generated on first run, but create manually for clarity)
-Content:
-
-// Extend H3 event context with custom properties
-declare module 'h3' {
-  interface H3EventContext {
-    // Add your custom context properties here
-    // Example:
-    // db?: Database
-    // auth?: { userId: string }
-  }
-}
-
-Note: This file lets you add custom properties to resolver context
-Validation: File exists in server/graphql/
-
-## STEP 5: CREATE CONFIG (Optional)
-File: server/graphql/config.ts
-Action: CREATE NEW FILE (auto-generated, customize if needed)
-Content:
-
-// Custom GraphQL Yoga configuration
-export default defineGraphQLConfig({
-  // Custom context enhancer, plugins, etc.
-  // See: https://the-guild.dev/graphql/yoga-server/docs
-})
-
-Note: Use this to customize GraphQL Yoga options
-Validation: File exists in server/graphql/
-
-## STEP 6: CREATE RESOLVERS
-File: server/graphql/users.resolver.ts
-Action: CREATE NEW FILE
-Content:
-
-// Must explicitly import (NOT auto-imported)
-import { defineQuery } from 'nitro-graphql/define'
-
-// ⚠️ CRITICAL: Use NAMED EXPORTS (not default export)
-export const userQueries = defineQuery({
-  users: async (_, __, context) => {
-    // context is H3EventContext - access event, storage, etc.
-    return [
-      { id: '1', name: 'John Doe', email: 'john@example.com' },
-      { id: '2', name: 'Jane Smith', email: 'jane@example.com' }
-    ]
-  },
-  user: async (_, { id }, context) => {
-    // Third parameter is context (H3EventContext)
-    const users = [
-      { id: '1', name: 'John Doe', email: 'john@example.com' },
-      { id: '2', name: 'Jane Smith', email: 'jane@example.com' }
-    ]
-    return users.find(u => u.id === id) || null
-  }
-})
-
-Validation: File ends with .resolver.ts, has import statement, and uses named export
-
-## STEP 7: START DEV SERVER
-Command: pnpm dev
-Expected Output: Server starts on http://localhost:3000
-Wait for: "Nitro built in X ms" message
-Note: context.ts and config.ts will auto-generate if you skipped steps 4-5
-
-## VALIDATION CHECKLIST
-- [ ] Navigate to http://localhost:3000/api/graphql - should show GraphQL playground
-- [ ] Health check: http://localhost:3000/api/graphql/health - should return OK
-- [ ] Run this query in playground:
-  ```graphql
-  query {
-    users {
-      id
-      name
-      email
-    }
-  }
-  ```
-  Expected: Returns 2 users
-- [ ] Check .nuxt/types/nitro-graphql-server.d.ts exists (types auto-generated)
-
-## FILE STRUCTURE CREATED
-```
-server/
-  graphql/
-    schema.graphql          ← GraphQL type definitions
-    context.ts              ← H3 event context augmentation (optional)
-    config.ts               ← GraphQL Yoga config (optional)
-    users.resolver.ts       ← Query resolvers
-.nuxt/
-  types/
-    nitro-graphql-server.d.ts  ← Auto-generated types
-graphql.config.ts           ← Auto-generated (for IDE tooling)
-```
-
-## CRITICAL RULES (MUST FOLLOW)
-❌ DO NOT use default exports in resolvers
-   Wrong: export default defineQuery({...})
-   Right: export const userQueries = defineQuery({...})
-
-❌ DO NOT name files without .resolver.ts extension
-   Wrong: users.ts or user-resolver.ts
-   Right: users.resolver.ts or user.resolver.ts
-
-✅ DO use named exports for all resolvers
-✅ DO place files in server/graphql/ directory
-✅ DO restart dev server if types don't generate
-
-## TROUBLESHOOTING
-Issue: "GraphQL endpoint returns 404"
-Fix: Ensure 'nitro-graphql/nuxt' is in modules array (not just 'nitro-graphql')
-
-Issue: "defineQuery is not defined"
-Fix: Add import statement at top of resolver file:
-  import { defineQuery } from 'nitro-graphql/define'
-
-Issue: "Types not generating"
-Fix: Check .nuxt/types/nitro-graphql-server.d.ts exists, if not restart dev server
-
-Issue: "Module not found: nitro-graphql"
-Fix: Run pnpm install again, check package.json has the package
-
-## NEXT STEPS (After Setup Works)
-1. Add mutations: "Add createUser and deleteUser mutations with H3 storage"
-2. Extend context: "Add database connection to context.ts and use it in resolvers"
-3. Use types: "Import and use TypeScript types from #graphql/server in resolvers"
-4. Add auth: "Add authentication middleware using context in resolvers"
-5. Custom config: "Configure GraphQL Yoga plugins in config.ts"
-
-Now implement this setup step-by-step.
-```
-
-</details>
-
-<details>
-<summary>⚡ <strong>Nitro Project</strong></summary>
-
-```
-Set up nitro-graphql in this Nitro project following these exact specifications:
-
-INSTALLATION:
-1. Run: pnpm add nitro-graphql graphql-yoga graphql
-
-CONFIGURATION (nitro.config.ts):
-import { defineNitroConfig } from 'nitro/config'
-
-export default defineNitroConfig({
-  modules: ['nitro-graphql'],
-  graphql: {
-    framework: 'graphql-yoga',
-  },
-})
-
-SCHEMA (server/graphql/schema.graphql):
-type Product {
-  id: ID!
-  name: String!
-  price: Float!
-}
-
-input CreateProductInput {
-  name: String!
-  price: Float!
-}
-
-type Query {
-  products: [Product!]!
-  product(id: ID!): Product
-}
-
-type Mutation {
-  createProduct(input: CreateProductInput!): Product!
-}
-
-RESOLVERS (server/graphql/products.resolver.ts):
-// Must explicitly import (NOT auto-imported)
-import { defineQuery, defineMutation } from 'nitro-graphql/define'
-
-// Use NAMED EXPORTS only
-export const productQueries = defineQuery({
-  products: async (_, __, context) => {
-    // Access H3 event context
-    const products = await context.storage?.getItem('products') || []
-    return products
-  },
-  product: async (_, { id }, context) => {
-    const products = await context.storage?.getItem('products') || []
-    return products.find(p => p.id === id)
-  }
-})
-
-export const productMutations = defineMutation({
-  createProduct: async (_, { input }, context) => {
-    const products = await context.storage?.getItem('products') || []
-    const product = {
-      id: Date.now().toString(),
-      ...input
-    }
-    products.push(product)
-    await context.storage?.setItem('products', products)
-    return product
-  }
-})
-
-KEY RULES:
-- Files: *.graphql for schemas, *.resolver.ts for resolvers
-- MUST use named exports (not default export)
-- MUST explicitly import: import { defineQuery } from 'nitro-graphql/define'
-- Context is the third parameter (access H3 event context)
-- Endpoint: http://localhost:3000/api/graphql
-
-Now implement this setup.
-```
-
-</details>
-
-<details>
-<summary>🎮 <strong>Apollo Server Setup</strong></summary>
-
-```
-Set up nitro-graphql with Apollo Server following these exact specifications:
-
-INSTALLATION:
-1. Run: pnpm add nitro-graphql @apollo/server @apollo/utils.withrequired graphql
-
-CONFIGURATION (nitro.config.ts):
-import { defineNitroConfig } from 'nitro/config'
-
-export default defineNitroConfig({
-  modules: ['nitro-graphql'],
-  graphql: {
-    framework: 'apollo-server',
-  },
-})
-
-SCHEMA (server/graphql/schema.graphql):
-type Book {
-  id: ID!
-  title: String!
-  author: String!
-}
-
-type Query {
-  books: [Book!]!
-  book(id: ID!): Book
-}
-
-type Mutation {
-  addBook(title: String!, author: String!): Book!
-}
-
-RESOLVERS (server/graphql/books.resolver.ts):
-// Must explicitly import (NOT auto-imported)
-import { defineResolver } from 'nitro-graphql/define'
-
-// IMPORTANT: Use NAMED EXPORTS
-export const bookResolver = defineResolver({
-  Query: {
-    books: async () => {
-      return [
-        { id: '1', title: '1984', author: 'George Orwell' }
-      ]
-    },
-    book: async (_, { id }) => {
-      return { id, title: '1984', author: 'George Orwell' }
-    }
-  },
-  Mutation: {
-    addBook: async (_, { title, author }) => {
-      return {
-        id: Date.now().toString(),
-        title,
-        author
-      }
-    }
-  }
-})
-
-KEY RULES:
-- framework: 'apollo-server' in config
-- MUST explicitly import: import { defineResolver } from 'nitro-graphql/define'
-- defineResolver for complete resolver maps
-- Named exports required (export const name = ...)
-- Apollo Sandbox: http://localhost:3000/api/graphql
-- Supports Apollo Federation with federation: { enabled: true }
-
-Now implement this setup.
-```
-
-</details>
-
-<details>
-<summary>🔄 <strong>Add Feature to Existing Setup</strong></summary>
-
-```
-Add a complete blog posts feature to my nitro-graphql API following these specifications:
-
-SCHEMA (server/graphql/posts/post.graphql):
-type Post {
-  id: ID!
-  title: String!
-  content: String!
-  authorId: ID!
-  createdAt: String!
-}
-
-input CreatePostInput {
-  title: String!
-  content: String!
-  authorId: ID!
-}
-
-input UpdatePostInput {
-  title: String
-  content: String
-}
-
-extend type Query {
-  posts(limit: Int = 10, offset: Int = 0): [Post!]!
-  post(id: ID!): Post
-}
-
-extend type Mutation {
-  createPost(input: CreatePostInput!): Post!
-  updatePost(id: ID!, input: UpdatePostInput!): Post
-  deletePost(id: ID!): Boolean!
-}
-
-RESOLVERS (server/graphql/posts/post.resolver.ts):
-// Must explicitly import (NOT auto-imported)
-import { defineQuery, defineMutation } from 'nitro-graphql/define'
-
-// Use NAMED EXPORTS
-export const postQueries = defineQuery({
-  posts: async (_, { limit, offset }, context) => {
-    const posts = await context.storage?.getItem('posts') || []
-    return posts.slice(offset, offset + limit)
-  },
-  post: async (_, { id }, context) => {
-    const posts = await context.storage?.getItem('posts') || []
-    return posts.find(p => p.id === id) || null
-  }
-})
-
-export const postMutations = defineMutation({
-  createPost: async (_, { input }, context) => {
-    const posts = await context.storage?.getItem('posts') || []
-    const post = {
-      id: Date.now().toString(),
-      ...input,
-      createdAt: new Date().toISOString()
-    }
-    posts.push(post)
-    await context.storage?.setItem('posts', posts)
-    return post
-  },
-  updatePost: async (_, { id, input }, context) => {
-    const posts = await context.storage?.getItem('posts') || []
-    const index = posts.findIndex(p => p.id === id)
-    if (index === -1) return null
-    posts[index] = { ...posts[index], ...input }
-    await context.storage?.setItem('posts', posts)
-    return posts[index]
-  },
-  deletePost: async (_, { id }, context) => {
-    const posts = await context.storage?.getItem('posts') || []
-    const filtered = posts.filter(p => p.id !== id)
-    await context.storage?.setItem('posts', filtered)
-    return filtered.length < posts.length
-  }
-})
-
-TYPE USAGE:
-After dev server restarts, types are auto-generated in:
-- .nitro/types/nitro-graphql-server.d.ts (server types)
-- .nuxt/types/nitro-graphql-server.d.ts (for Nuxt)
-
-Import types:
-import type { Post, CreatePostInput } from '#graphql/server'
-
-KEY RULES:
-- MUST explicitly import: import { defineQuery, defineMutation } from 'nitro-graphql/define'
-- Use "extend type" to add to existing Query/Mutation
-- Named exports required
-- Context has H3 event properties
-- Types auto-generate on file changes
-
-Now implement this feature.
-```
-
-</details>
-
 ### Working with Your GraphQL API
 
 Once set up, you can ask Claude Code for help with:

package/dist/rollup.mjs

@@ -94,8 +94,8 @@ async function rollupConfig(app) {
 		}
 	});
 	app.hooks.hook("dev:reload", async () => {
-		await serverTypeGeneration(app);
-		await clientTypeGeneration(app);
+		await serverTypeGeneration(app, { silent: true });
+		await clientTypeGeneration(app, { silent: true });
 	});
 }
 function virtualSchemas(app) {

package/dist/routes/apollo-server.d.mts

@@ -1,6 +1,6 @@
-import * as h33 from "h3";
+import * as h30 from "h3";
 
 //#region src/routes/apollo-server.d.ts
-declare const _default: h33.EventHandlerWithFetch<h33.EventHandlerRequest, Promise<any>>;
+declare const _default: h30.EventHandlerWithFetch<h30.EventHandlerRequest, Promise<any>>;
 //#endregion
 export { _default as default };

package/dist/routes/debug.d.mts

@@ -1,4 +1,4 @@
-import * as h35 from "h3";
+import * as h31 from "h3";
 
 //#region src/routes/debug.d.ts
 
@@ -10,7 +10,7 @@ import * as h35 from "h3";
  * - /_nitro/graphql/debug - HTML dashboard
  * - /_nitro/graphql/debug?format=json - JSON API
  */
-declare const _default: h35.EventHandlerWithFetch<h35.EventHandlerRequest, Promise<string | {
+declare const _default: h31.EventHandlerWithFetch<h31.EventHandlerRequest, Promise<string | {
   timestamp: string;
   environment: {
     dev: any;

package/dist/routes/graphql-yoga.d.mts

@@ -1,6 +1,6 @@
-import * as h30 from "h3";
+import * as h35 from "h3";
 
 //#region src/routes/graphql-yoga.d.ts
-declare const _default: h30.EventHandlerWithFetch<h30.EventHandlerRequest, Promise<Response>>;
+declare const _default: h35.EventHandlerWithFetch<h35.EventHandlerRequest, Promise<Response>>;
 //#endregion
 export { _default as default };

package/dist/routes/health.d.mts

@@ -1,7 +1,7 @@
-import * as h31 from "h3";
+import * as h33 from "h3";
 
 //#region src/routes/health.d.ts
-declare const _default: h31.EventHandlerWithFetch<h31.EventHandlerRequest, Promise<{
+declare const _default: h33.EventHandlerWithFetch<h33.EventHandlerRequest, Promise<{
   status: string;
   message: string;
   timestamp: string;

package/dist/setup.mjs

@@ -12,20 +12,21 @@ import consola from "consola";
 import { dirname, join, relative, resolve } from "pathe";
 
 //#region src/setup.ts
+const logger = consola.withTag("nitro-graphql");
 /**
 * Shared setup logic for nitro-graphql module
 * Used by both the direct Nitro module export and the Vite plugin's nitro: hook
 */
 async function setupNitroGraphQL(nitro) {
-	if (!nitro.options.graphql?.framework) consola.warn("No GraphQL framework specified. Please set graphql.framework to \"graphql-yoga\" or \"apollo-server\".");
+	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) {
-			consola.error("External services configuration errors:");
-			for (const error of validationErrors) consola.error(`  - ${error}`);
+			logger.error("External services configuration errors:");
+			for (const error of validationErrors) logger.error(`  - ${error}`);
 			throw new Error("Invalid external services configuration");
 		}
-		consola.info(`Configured ${nitro.options.graphql.externalServices.length} external GraphQL services`);
+		logger.info(`Configured ${nitro.options.graphql.externalServices.length} external GraphQL services`);
 	}
 	const { getDefaultPaths } = await import("./utils/path-resolver.mjs");
 	const defaultPaths = getDefaultPaths(nitro);
@@ -59,7 +60,7 @@ async function setupNitroGraphQL(nitro) {
 		},
 		playground: true
 	});
-	if (nitro.options.graphql?.federation?.enabled) consola.info(`Apollo Federation enabled for service: ${nitro.options.graphql.federation.serviceName || "unnamed"}`);
+	if (nitro.options.graphql?.federation?.enabled) logger.info(`Apollo Federation enabled for service: ${nitro.options.graphql.federation.serviceName || "unnamed"}`);
 	const graphqlBuildDir = resolve(nitro.options.buildDir, "graphql");
 	nitro.graphql.buildDir = graphqlBuildDir;
 	const watchDirs = [];
@@ -95,11 +96,20 @@ async function setupNitroGraphQL(nitro) {
 		ignoreInitial: true,
 		ignored: [...nitro.options.ignore, ...generateLayerIgnorePatterns()]
 	}).on("all", async (_, path) => {
-		if (path.endsWith(".graphql") || path.endsWith(".gql")) if (path.includes(nitro.graphql.serverDir) || path.includes("server/graphql") || path.includes("server\\graphql")) {
-			await serverTypeGeneration(nitro);
-			await clientTypeGeneration(nitro);
+		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 await clientTypeGeneration(nitro);
+		} else {
+			logger.success("Types regenerated");
+			await clientTypeGeneration(nitro, { silent: true });
+		}
 	});
 	nitro.hooks.hook("close", () => {
 		watcher.close();
@@ -111,33 +121,17 @@ async function setupNitroGraphQL(nitro) {
 	const directives = await scanDirectives(nitro);
 	nitro.scanDirectives = directives;
 	await generateDirectiveSchemas(nitro, directives);
+	let hasShownInitialLogs = false;
 	nitro.hooks.hook("dev:start", async () => {
-		const schemas = await scanSchemas(nitro);
-		nitro.scanSchemas = schemas;
+		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);
-		const docs = await scanDocs(nitro);
-		nitro.scanDocuments = docs;
-		if (nitro.options.dev) {
-			consola.box({
-				title: "Nitro GraphQL",
-				message: [
-					`Framework: ${nitro.options.graphql?.framework || "Not configured"}`,
-					`Schemas: ${schemas.length}`,
-					`Resolvers: ${resolvers.length}`,
-					`Directives: ${directives$1.length}`,
-					`Documents: ${docs.length}`,
-					"",
-					"Debug Dashboard: /_nitro/graphql/debug"
-				].join("\n"),
-				style: {
-					borderColor: "cyan",
-					borderStyle: "rounded"
-				}
-			});
+		nitro.scanDocuments = await scanDocs(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 = {
@@ -156,16 +150,16 @@ async function setupNitroGraphQL(nitro) {
 				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) consola.success(`[nitro-graphql] ${totalExports} resolver export(s): ${breakdown.join(", ")}`);
-			} else consola.warn("[nitro-graphql] No resolvers found. Check /_nitro/graphql/debug for details.");
+				if (breakdown.length > 0) logger.success(`${totalExports} resolver export(s): ${breakdown.join(", ")}`);
+			} else logger.warn("No resolvers found. Check /_nitro/graphql/debug for details.");
 		}
 	});
 	await rollupConfig(nitro);
 	await serverTypeGeneration(nitro);
-	await clientTypeGeneration(nitro);
+	await clientTypeGeneration(nitro, { isInitial: true });
 	nitro.hooks.hook("close", async () => {
-		await serverTypeGeneration(nitro);
-		await clientTypeGeneration(nitro);
+		await serverTypeGeneration(nitro, { silent: true });
+		await clientTypeGeneration(nitro, { silent: true });
 	});
 	const runtime = fileURLToPath(new URL("routes", import.meta.url));
 	const methods = [
@@ -188,14 +182,11 @@ async function setupNitroGraphQL(nitro) {
 		handler: join(runtime, "health"),
 		method: "GET"
 	});
-	if (nitro.options.dev) {
-		nitro.options.handlers.push({
-			route: "/_nitro/graphql/debug",
-			handler: join(runtime, "debug"),
-			method: "GET"
-		});
-		consola.info("[nitro-graphql] Debug dashboard available at: /_nitro/graphql/debug");
-	}
+	if (nitro.options.dev) nitro.options.handlers.push({
+		route: "/_nitro/graphql/debug",
+		handler: join(runtime, "debug"),
+		method: "GET"
+	});
 	if (nitro.options.imports) {
 		nitro.options.imports.presets ??= [];
 		nitro.options.imports.presets.push({
@@ -380,10 +371,10 @@ declare module 'nitro/h3' {
 export {}
 `, "server context.d.ts");
 		if (existsSync(join(nitro.graphql.serverDir, "context.ts"))) {
-			consola.warn("nitro-graphql: Found context.ts file. Please rename it to context.d.ts for type-only definitions.");
-			consola.info("The context file should now be context.d.ts instead of 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 consola.info("[nitro-graphql] Scaffold file generation is disabled (library mode)");
+	} else logger.info("Scaffold file generation is disabled (library mode)");
 }
 
 //#endregion

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

@@ -23,7 +23,10 @@ declare function loadExternalSchema(service: ExternalGraphQLService, buildDir?:
  */
 declare function downloadAndSaveSchema(service: ExternalGraphQLService, buildDir: string): Promise<string | undefined>;
 declare function loadGraphQLDocuments(patterns: string | string[]): Promise<Source[]>;
-declare function generateClientTypes(schema: GraphQLSchema, docs: Source[], config?: CodegenClientConfig, sdkConfig?: GenericSdkConfig, outputPath?: string, serviceName?: string, virtualTypesPath?: string): Promise<false | {
+declare function generateClientTypes(schema: GraphQLSchema, docs: Source[], config?: CodegenClientConfig, sdkConfig?: GenericSdkConfig, outputPath?: string, serviceName?: string, virtualTypesPath?: string, options?: {
+  silent?: boolean;
+  isInitial?: boolean;
+}): Promise<false | {
   types: string;
   sdk: string;
 }>;

package/dist/utils/client-codegen.mjs

@@ -165,9 +165,9 @@ async function loadGraphQLDocuments(patterns) {
 		else throw e;
 	}
 }
-async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, outputPath, serviceName, virtualTypesPath) {
+async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, outputPath, serviceName, virtualTypesPath, options = {}) {
 	if (docs.length === 0 && !serviceName) {
-		consola$1.info("No client GraphQL files found. Skipping client type generation.");
+		if (!options.silent && options.isInitial) consola$1.info("No client GraphQL files found. Skipping client type generation.");
 		return false;
 	}
 	const serviceLabel = serviceName ? `:${serviceName}` : "";

package/dist/utils/index.mjs

@@ -1,7 +1,7 @@
 import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.mjs";
 import { createDefaultMaskError } from "./errors.mjs";
 import { readFile } from "node:fs/promises";
-import { join, relative } from "pathe";
+import { basename, join, relative } from "pathe";
 import { hash } from "ohash";
 import { parseAsync } from "oxc-parser";
 import { glob } from "tinyglobby";
@@ -77,6 +77,17 @@ async function scanResolvers(nitro) {
 	for (const file of files) try {
 		const fileContent = await readFile(file.fullPath, "utf-8");
 		const parsed = await parseAsync(file.fullPath, fileContent);
+		if (parsed.errors && parsed.errors.length > 0) {
+			if (nitro.options.dev) {
+				const fileName = basename(file.fullPath);
+				const firstError = parsed.errors[0];
+				const location = firstError.labels?.[0];
+				const lineInfo = location ? `:${location.start}` : "";
+				const message = firstError.message.split(",")[0];
+				console.error(`✖ ${fileName}${lineInfo} - ${message}`);
+			}
+			continue;
+		}
 		const exports = {
 			imports: [],
 			specifier: file.fullPath
@@ -126,7 +137,6 @@ async function scanResolvers(nitro) {
 			}
 		}
 		if (nitro.options.dev) {
-			const relPath = relative(nitro.options.rootDir, file.fullPath);
 			if (hasDefaultExport && !hasNamedExport) nitro.logger.warn(`[nitro-graphql] ${relPath}: Using default export instead of named export. Resolvers must use named exports like "export const myResolver = defineQuery(...)". Default exports are not detected.`);
 			if (exports.imports.length === 0 && hasNamedExport) {
 				const validFunctions = VALID_DEFINE_FUNCTIONS.join(", ");
@@ -136,8 +146,8 @@ async function scanResolvers(nitro) {
 		}
 		if (exports.imports.length > 0) exportName.push(exports);
 	} catch (error) {
-		const relPath = relative(nitro.options.rootDir, file.fullPath);
-		nitro.logger.error(`[nitro-graphql] Failed to parse resolver file ${relPath}:`, error);
+		const relPath$1 = relative(nitro.options.rootDir, file.fullPath);
+		nitro.logger.error(`[nitro-graphql] Failed to parse resolver file ${relPath$1}:`, error);
 	}
 	return exportName;
 }

package/dist/utils/type-generation.d.mts

@@ -1,7 +1,12 @@
 import { Nitro } from "nitro/types";
 
 //#region src/utils/type-generation.d.ts
-declare function serverTypeGeneration(app: Nitro): Promise<void>;
-declare function clientTypeGeneration(nitro: Nitro): Promise<void>;
+declare function serverTypeGeneration(app: Nitro, options?: {
+  silent?: boolean;
+}): Promise<void>;
+declare function clientTypeGeneration(nitro: Nitro, options?: {
+  silent?: boolean;
+  isInitial?: boolean;
+}): Promise<void>;
 //#endregion
 export { clientTypeGeneration, serverTypeGeneration };

package/dist/utils/type-generation.mjs

@@ -12,6 +12,7 @@ import { mergeTypeDefs } from "@graphql-tools/merge";
 import { printSchemaWithDirectives } from "@graphql-tools/utils";
 
 //#region src/utils/type-generation.ts
+const logger = consola.withTag("nitro-graphql");
 function generateGraphQLIndexFile(nitro, clientDir, externalServices = []) {
 	if (!shouldGenerateClientUtils(nitro)) return;
 	const placeholders = getDefaultPaths(nitro);
@@ -238,15 +239,15 @@ function validateNoDuplicateTypes(schemas, schemaStrings) {
 	}
 	return true;
 }
-async function serverTypeGeneration(app) {
+async function serverTypeGeneration(app, options = {}) {
 	try {
 		if (!shouldGenerateTypes(app)) {
-			consola.debug("[nitro-graphql] Server type generation is disabled");
+			logger.debug("Server type generation is disabled");
 			return;
 		}
 		const schemas = app.scanSchemas || [];
 		if (!schemas.length) {
-			consola.info("No GraphQL definitions found for server type generation.");
+			if (!options.silent) consola.info("No GraphQL definitions found for server type generation.");
 			return;
 		}
 		const schemaStrings = loadFilesSync(schemas).map((schema$1) => typeof schema$1 === "string" ? schema$1 : schema$1.loc?.source?.body || "").filter(Boolean);
@@ -269,18 +270,18 @@ async function serverTypeGeneration(app) {
 		if (serverTypesPath) {
 			mkdirSync(dirname(serverTypesPath), { recursive: true });
 			writeFileSync(serverTypesPath, data, "utf-8");
-			consola.success(`[nitro-graphql] Generated server types at: ${serverTypesPath}`);
+			if (!options.silent) logger.success(`Generated server types at: ${serverTypesPath}`);
 		}
 	} catch (error) {
-		consola.error("Server schema generation error:", error);
+		logger.error("Server schema generation error:", error);
 	}
 }
-async function clientTypeGeneration(nitro) {
+async function clientTypeGeneration(nitro, options = {}) {
 	try {
-		if (nitro.scanSchemas && nitro.scanSchemas.length > 0) await generateMainClientTypes(nitro);
-		if (nitro.options.graphql?.externalServices?.length) await generateExternalServicesTypes(nitro);
+		if (nitro.scanSchemas && nitro.scanSchemas.length > 0) await generateMainClientTypes(nitro, options);
+		if (nitro.options.graphql?.externalServices?.length) await generateExternalServicesTypes(nitro, options);
 	} catch (error) {
-		consola.error("Client schema generation error:", error);
+		logger.error("Client schema generation error:", error);
 	}
 }
 /**
@@ -311,17 +312,17 @@ function checkOldStructure(clientDir) {
 🚫 The old files will cause import conflicts until moved!`);
 	}
 }
-async function generateMainClientTypes(nitro) {
+async function generateMainClientTypes(nitro, options = {}) {
 	checkOldStructure(nitro.graphql.clientDir);
 	const docs = nitro.scanDocuments;
 	const loadDocs = await loadGraphQLDocuments(docs);
 	const schemaFilePath = join(nitro.graphql.buildDir, "schema.graphql");
 	if (!existsSync(schemaFilePath)) {
-		consola.info("Schema file not ready yet for client type generation. Server types need to be generated first.");
+		if (!options.silent) consola.info("Schema file not ready yet for client type generation. Server types need to be generated first.");
 		return;
 	}
 	const graphqlString = readFileSync(schemaFilePath, "utf-8");
-	const types = await generateClientTypes(nitro.options.graphql?.federation?.enabled === true ? buildSubgraphSchema([{ typeDefs: parse(graphqlString) }]) : buildSchema(graphqlString), loadDocs, nitro.options.graphql?.codegen?.client ?? {}, nitro.options.graphql?.codegen?.clientSDK ?? {});
+	const types = await generateClientTypes(nitro.options.graphql?.federation?.enabled === true ? buildSubgraphSchema([{ typeDefs: parse(graphqlString) }]) : buildSchema(graphqlString), loadDocs, nitro.options.graphql?.codegen?.client ?? {}, nitro.options.graphql?.codegen?.clientSDK ?? {}, void 0, void 0, void 0, options);
 	if (types === false) return;
 	const placeholders = getDefaultPaths(nitro);
 	const typesConfig = getTypesConfig(nitro);
@@ -330,22 +331,22 @@ async function generateMainClientTypes(nitro) {
 	if (clientTypesPath) {
 		mkdirSync(dirname(clientTypesPath), { recursive: true });
 		writeFileSync(clientTypesPath, types.types, "utf-8");
-		consola.success(`[nitro-graphql] Generated client types at: ${clientTypesPath}`);
+		if (!options.silent) logger.success(`Generated client types at: ${clientTypesPath}`);
 	}
 	const sdkPath = resolveFilePath(sdkConfig.main, sdkConfig.enabled, true, "{clientGraphql}/default/sdk.ts", placeholders);
 	if (sdkPath) {
 		mkdirSync(dirname(sdkPath), { recursive: true });
 		writeFileSync(sdkPath, types.sdk, "utf-8");
-		consola.success(`[nitro-graphql] Generated SDK at: ${sdkPath}`);
+		if (!options.silent) logger.success(`Generated SDK at: ${sdkPath}`);
 	}
 	generateNuxtOfetchClient(nitro, nitro.graphql.clientDir, "default");
 	const externalServices = nitro.options.graphql?.externalServices || [];
 	if (externalServices.length > 0) generateGraphQLIndexFile(nitro, nitro.graphql.clientDir, externalServices);
 }
-async function generateExternalServicesTypes(nitro) {
+async function generateExternalServicesTypes(nitro, options = {}) {
 	const externalServices = nitro.options.graphql?.externalServices || [];
 	for (const service of externalServices) try {
-		consola.info(`[graphql:${service.name}] Processing external service`);
+		if (!options.silent) consola.info(`[graphql:${service.name}] Processing external service`);
 		await downloadAndSaveSchema(service, nitro.options.buildDir);
 		const schema = await loadExternalSchema(service, nitro.options.buildDir);
 		if (!schema) {
@@ -379,16 +380,16 @@ async function generateExternalServicesTypes(nitro) {
 		if (serviceTypesPath) {
 			mkdirSync(dirname(serviceTypesPath), { recursive: true });
 			writeFileSync(serviceTypesPath, types.types, "utf-8");
-			consola.success(`[graphql:${service.name}] Generated types at: ${serviceTypesPath}`);
+			if (!options.silent) consola.success(`[graphql:${service.name}] Generated types at: ${serviceTypesPath}`);
 		}
 		const serviceSdkPath = resolveFilePath(service.paths?.sdk ?? sdkConfig.external, sdkConfig.enabled, true, "{clientGraphql}/{serviceName}/sdk.ts", placeholders);
 		if (serviceSdkPath) {
 			mkdirSync(dirname(serviceSdkPath), { recursive: true });
 			writeFileSync(serviceSdkPath, types.sdk, "utf-8");
-			consola.success(`[graphql:${service.name}] Generated SDK at: ${serviceSdkPath}`);
+			if (!options.silent) consola.success(`[graphql:${service.name}] Generated SDK at: ${serviceSdkPath}`);
 		}
 		generateExternalOfetchClient(nitro, service, service.endpoint);
-		consola.success(`[graphql:${service.name}] External service types generated successfully`);
+		if (!options.silent) consola.success(`[graphql:${service.name}] External service types generated successfully`);
 	} catch (error) {
 		consola.error(`[graphql:${service.name}] External service generation failed:`, error);
 	}

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "nitro-graphql",
   "type": "module",
-  "version": "2.0.0-beta.25",
-  "packageManager": "pnpm@10.22.0",
+  "version": "2.0.0-beta.26",
   "description": "GraphQL integration for Nitro",
   "license": "MIT",
   "sideEffects": false,
@@ -71,22 +70,6 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "prepack": "pnpm build",
-    "build": "tsdown",
-    "dev": "tsdown --watch",
-    "bumpp": "bumpp package.json",
-    "release": "pnpm build && pnpm bumpp && pnpm publish --no-git-checks --access public",
-    "playground:nitro": "cd playgrounds/nitro && pnpm install && pnpm dev",
-    "playground:nuxt": "cd playgrounds/nuxt && pnpm install && pnpm dev",
-    "playground:federation": "cd playgrounds/federation && pnpm install && pnpm dev",
-    "docs:dev": "cd .docs && pnpm install && pnpm update:metadata && pnpm dev",
-    "docs:build": "cd .docs && pnpm install && pnpm update:metadata && pnpm build",
-    "docs:preview": "cd .docs && pnpm preview",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "test:types": "tsc --noEmit"
-  },
   "peerDependencies": {
     "@apollo/server": "^5.0.0",
     "@apollo/utils.withrequired": "^3.0.0",
@@ -103,57 +86,66 @@
     }
   },
   "dependencies": {
-    "@apollo/subgraph": "catalog:",
-    "@graphql-codegen/core": "catalog:",
-    "@graphql-codegen/import-types-preset": "catalog:",
-    "@graphql-codegen/typescript": "catalog:",
-    "@graphql-codegen/typescript-generic-sdk": "catalog:",
-    "@graphql-codegen/typescript-operations": "catalog:",
-    "@graphql-codegen/typescript-resolvers": "catalog:",
-    "@graphql-tools/graphql-file-loader": "catalog:",
-    "@graphql-tools/load": "catalog:",
-    "@graphql-tools/load-files": "catalog:",
-    "@graphql-tools/merge": "catalog:",
-    "@graphql-tools/schema": "catalog:",
-    "@graphql-tools/url-loader": "catalog:",
-    "@graphql-tools/utils": "catalog:",
-    "chokidar": "catalog:",
-    "consola": "catalog:",
-    "defu": "catalog:",
-    "graphql-config": "catalog:",
-    "graphql-scalars": "catalog:",
-    "knitwork": "catalog:",
-    "ohash": "catalog:",
-    "oxc-parser": "catalog:",
-    "pathe": "catalog:",
-    "tinyglobby": "catalog:"
+    "@apollo/subgraph": "^2.12.1",
+    "@graphql-codegen/core": "^5.0.0",
+    "@graphql-codegen/import-types-preset": "^3.0.1",
+    "@graphql-codegen/typescript": "^5.0.4",
+    "@graphql-codegen/typescript-generic-sdk": "^4.0.2",
+    "@graphql-codegen/typescript-operations": "^5.0.4",
+    "@graphql-codegen/typescript-resolvers": "^5.1.2",
+    "@graphql-tools/graphql-file-loader": "^8.1.6",
+    "@graphql-tools/load": "^8.1.6",
+    "@graphql-tools/load-files": "^7.0.1",
+    "@graphql-tools/merge": "^9.1.5",
+    "@graphql-tools/schema": "^10.0.29",
+    "@graphql-tools/url-loader": "^9.0.4",
+    "@graphql-tools/utils": "^10.10.3",
+    "chokidar": "^4.0.3",
+    "consola": "^3.4.2",
+    "defu": "^6.1.4",
+    "graphql-config": "^5.1.5",
+    "graphql-scalars": "^1.25.0",
+    "knitwork": "^1.3.0",
+    "ohash": "^2.0.11",
+    "oxc-parser": "^0.97.0",
+    "pathe": "^2.0.3",
+    "tinyglobby": "^0.2.15"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "catalog:",
-    "@nuxt/kit": "catalog:",
-    "@nuxt/schema": "catalog:",
-    "@types/node": "catalog:",
-    "@vitejs/devtools": "catalog:",
-    "bumpp": "catalog:",
-    "changelogen": "catalog:",
-    "crossws": "catalog:",
-    "eslint": "catalog:",
-    "graphql": "catalog:",
-    "graphql-yoga": "catalog:",
-    "h3": "catalog:",
-    "nitro": "catalog:",
-    "tsdown": "catalog:",
-    "typescript": "catalog:",
-    "vite": "catalog:",
-    "vitepress-plugin-llms": "catalog:"
-  },
-  "pnpm": {
-    "overrides": {
-      "nitro": "npm:nitro-nightly@latest",
-      "vite": "npm:rolldown-vite@latest"
-    }
+    "@antfu/eslint-config": "^6.2.0",
+    "@nuxt/kit": "^4.2.1",
+    "@nuxt/schema": "^4.2.1",
+    "@types/node": "^24.10.1",
+    "@vitejs/devtools": "^0.0.0-alpha.16",
+    "bumpp": "^10.3.1",
+    "changelogen": "^0.6.2",
+    "crossws": "^0.4.1",
+    "eslint": "^9.39.1",
+    "graphql": "^16.12.0",
+    "graphql-yoga": "^5.16.2",
+    "h3": "^2.0.1-rc.5",
+    "nitro": "npm:nitro-nightly@latest",
+    "tsdown": "^0.16.4",
+    "typescript": "^5.9.3",
+    "vite": "npm:rolldown-vite@latest",
+    "vitepress-plugin-llms": "^1.9.1"
   },
   "resolutions": {
     "nitro-graphql": "link:."
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "bumpp": "bumpp package.json",
+    "release": "pnpm build && pnpm bumpp && pnpm publish --no-git-checks --access public",
+    "playground:nitro": "cd playgrounds/nitro && pnpm install && pnpm dev",
+    "playground:nuxt": "cd playgrounds/nuxt && pnpm install && pnpm dev",
+    "playground:federation": "cd playgrounds/federation && pnpm install && pnpm dev",
+    "docs:dev": "cd .docs && pnpm install && pnpm update:metadata && pnpm dev",
+    "docs:build": "cd .docs && pnpm install && pnpm update:metadata && pnpm build",
+    "docs:preview": "cd .docs && pnpm preview",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test:types": "tsc --noEmit"
   }
-}
+}