nitro-graphql 1.1.2 → 1.2.0

package/README.md

@@ -30,8 +30,23 @@
 - 🔄 **Hot Reload**: Development mode with automatic schema and resolver updates
 - 📦 **Optimized Bundling**: Smart chunking and dynamic imports for production
 - 🌐 **Nuxt Integration**: First-class Nuxt.js support with dedicated module
+- 🎭 **Custom Directives**: Create reusable GraphQL directives with automatic schema generation
+- 🔗 **Multi-Service Support**: Connect to multiple external GraphQL APIs alongside your main server
 
-## 🚀 Quick Start
+## 🎯 Used Projects
+
+Projects using Nitro GraphQL in production:
+
+- [**Nitroping**](https://github.com/productdevbook/nitroping) - Open-source, self-hosted push notification service
+
+## 🎥 Video Tutorials
+
+Learn how to use Nitro GraphQL with these video tutorials:
+
+- [**Nuxt 4 Usage**](https://x.com/productdevbook/status/1947314569531076633) - How to integrate Nitro GraphQL with Nuxt 4
+- [**Nitro Usage**](https://x.com/productdevbook/status/1945759751393976348) - How to use Nitro GraphQL with standalone Nitro
+
+## 🎯 Quick Start
 
 ### Step 1: Installation
 
@@ -181,6 +196,10 @@ server/
 ├── graphql/
 │   ├── schema.graphql              # Main schema with scalars and base types
 │   ├── hello.resolver.ts           # Global resolvers (use named exports)
+│   ├── directives/                 # Custom GraphQL directives
+│   │   ├── auth.directive.ts       # Authentication directive
+│   │   ├── cache.directive.ts      # Caching directive
+│   │   └── validate.directive.ts   # Validation directive
 │   ├── users/
 │   │   ├── user.graphql           # User schema definitions
 │   │   ├── user-queries.resolver.ts # User query resolvers (use named exports)
@@ -615,6 +634,90 @@ export const postTypes = defineType({
 
 </details>
 
+<details>
+<summary><strong>defineDirective</strong> - Create custom GraphQL directives</summary>
+
+```ts
+import { defineDirective } from 'nitro-graphql/utils/define'
+import { getDirective, MapperKind, mapSchema } from '@graphql-tools/utils'
+import { defaultFieldResolver, GraphQLError } from 'graphql'
+
+export const authDirective = defineDirective({
+  name: 'auth',
+  locations: ['FIELD_DEFINITION', 'OBJECT'],
+  args: {
+    requires: {
+      type: 'String',
+      defaultValue: 'USER',
+      description: 'Required role to access this field',
+    },
+  },
+  description: 'Directive to check authentication and authorization',
+  transformer: (schema) => {
+    return mapSchema(schema, {
+      [MapperKind.OBJECT_FIELD]: (fieldConfig) => {
+        const authDirectiveConfig = getDirective(schema, fieldConfig, 'auth')?.[0]
+        
+        if (authDirectiveConfig) {
+          const { resolve = defaultFieldResolver } = fieldConfig
+          
+          fieldConfig.resolve = async function (source, args, context, info) {
+            if (!context.user) {
+              throw new GraphQLError('You must be logged in')
+            }
+            
+            if (context.user.role !== authDirectiveConfig.requires) {
+              throw new GraphQLError('Insufficient permissions')
+            }
+            
+            return resolve(source, args, context, info)
+          }
+        }
+        
+        return fieldConfig
+      },
+    })
+  },
+})
+```
+
+**Usage in Schema:**
+```graphql
+type User {
+  id: ID!
+  name: String!
+  email: String! @auth(requires: "ADMIN")
+  secretData: String @auth(requires: "SUPER_ADMIN")
+}
+
+type Query {
+  users: [User!]! @auth
+  adminStats: AdminStats @auth(requires: "ADMIN")
+}
+```
+
+**Available Argument Types:**
+- Basic scalars: `String`, `Int`, `Float`, `Boolean`, `ID`, `JSON`, `DateTime`
+- Non-nullable: `String!`, `Int!`, `Float!`, `Boolean!`, `ID!`, `JSON!`, `DateTime!`
+- Arrays: `[String]`, `[String!]`, `[String]!`, `[String!]!` (and all combinations for other types)
+- Custom types: Any string for your custom GraphQL types
+
+**Helper Function:**
+```ts
+export const validateDirective = defineDirective({
+  name: 'validate',
+  locations: ['FIELD_DEFINITION', 'ARGUMENT_DEFINITION'],
+  args: {
+    minLength: arg('Int', { description: 'Minimum length' }),
+    maxLength: arg('Int', { description: 'Maximum length' }),
+    pattern: arg('String', { description: 'Regex pattern' }),
+  },
+  // ... transformer implementation
+})
+```
+
+</details>
+
 <details>
 <summary><strong>defineSchema</strong> - Define custom schema with validation</summary>
 
@@ -741,6 +844,75 @@ export default defineNitroConfig({
 
 ## 🔥 Advanced Features
 
+<details>
+<summary><strong>Custom Directives</strong></summary>
+
+Create reusable GraphQL directives with automatic schema generation:
+
+```ts
+// server/graphql/directives/auth.directive.ts
+import { defineDirective } from 'nitro-graphql/utils/define'
+import { getDirective, MapperKind, mapSchema } from '@graphql-tools/utils'
+
+export const authDirective = defineDirective({
+  name: 'auth',
+  locations: ['FIELD_DEFINITION', 'OBJECT'],
+  args: {
+    requires: {
+      type: 'String',
+      defaultValue: 'USER',
+      description: 'Required role to access this field',
+    },
+  },
+  description: 'Authentication and authorization directive',
+  transformer: (schema) => {
+    return mapSchema(schema, {
+      [MapperKind.OBJECT_FIELD]: (fieldConfig) => {
+        const authConfig = getDirective(schema, fieldConfig, 'auth')?.[0]
+        if (authConfig) {
+          // Transform field resolvers to check authentication
+          const { resolve = defaultFieldResolver } = fieldConfig
+          fieldConfig.resolve = async (source, args, context, info) => {
+            if (!context.user || context.user.role !== authConfig.requires) {
+              throw new GraphQLError('Access denied')
+            }
+            return resolve(source, args, context, info)
+          }
+        }
+        return fieldConfig
+      },
+    })
+  },
+})
+```
+
+**Common Directive Examples:**
+- `@auth(requires: "ADMIN")` - Role-based authentication
+- `@cache(ttl: 300, scope: "PUBLIC")` - Field-level caching
+- `@rateLimit(limit: 10, window: 60)` - Rate limiting
+- `@validate(minLength: 5, maxLength: 100)` - Input validation
+- `@transform(upper: true, trim: true)` - Data transformation
+- `@permission(roles: ["ADMIN", "MODERATOR"])` - Multi-role permissions
+
+**Usage in Schema:**
+```graphql
+type User {
+  id: ID!
+  name: String!
+  email: String! @auth(requires: "ADMIN")
+  posts: [Post!]! @cache(ttl: 300)
+}
+
+type Query {
+  users: [User!]! @rateLimit(limit: 100, window: 3600)
+  sensitiveData: String @auth(requires: "SUPER_ADMIN")
+}
+```
+
+The module automatically generates the directive schema definitions and integrates them with both GraphQL Yoga and Apollo Server.
+
+</details>
+
 <details>
 <summary><strong>Custom Scalars</strong></summary>
 
@@ -1102,6 +1274,249 @@ Help us improve nitro-graphql! Pick any item and contribute:
 > [!NOTE]
 > Have other ideas? Open an issue to discuss!
 
+## 🔗 Multi-Service GraphQL Support
+
+Connect to multiple external GraphQL APIs alongside your main GraphQL server. Perfect for integrating with services like GitHub API, Shopify API, or any GraphQL endpoint.
+
+### Configuration
+
+```typescript
+// nuxt.config.ts (for Nuxt projects)
+export default defineNuxtConfig({
+  nitro: {
+    graphql: {
+      framework: 'graphql-yoga',
+      externalServices: [
+        {
+          name: 'countries',
+          schema: 'https://countries.trevorblades.com',
+          endpoint: 'https://countries.trevorblades.com',
+          documents: ['app/graphql/external/countries/**/*.graphql'],
+          headers: {
+            // Optional: Add custom headers
+            'Authorization': 'Bearer your-token'
+          }
+        },
+        {
+          name: 'github',
+          schema: 'https://api.github.com/graphql',
+          endpoint: 'https://api.github.com/graphql',
+          documents: ['app/graphql/external/github/**/*.graphql'],
+          headers: () => ({
+            // Dynamic headers with function
+            'Authorization': `Bearer ${process.env.GITHUB_TOKEN}`
+          })
+        }
+      ]
+    }
+  }
+})
+```
+
+### Schema Download & Caching (Optional)
+
+For better performance and offline development, you can download and cache external schemas locally:
+
+```typescript
+// nuxt.config.ts
+export default defineNuxtConfig({
+  nitro: {
+    graphql: {
+      framework: 'graphql-yoga',
+      externalServices: [
+        {
+          name: 'github',
+          schema: 'https://docs.github.com/public/schema.docs.graphql',
+          endpoint: 'https://api.github.com/graphql',
+          downloadSchema: 'once', // Download mode (see options below)
+          downloadPath: './schemas/github.graphql', // Optional: custom download path
+          headers: () => ({
+            'Authorization': `Bearer ${process.env.GITHUB_TOKEN}`
+          })
+        }
+      ]
+    }
+  }
+})
+```
+
+**Download Modes:**
+
+| Mode | Behavior | Use Case |
+|------|----------|----------|
+| `true` or `'once'` | Download only if file doesn't exist | **Offline-friendly development** |
+| `'always'` | Check for updates on every build | **Always stay up-to-date** |
+| `'manual'` | Never download automatically | **Full manual control** |
+| `false` | Disable schema downloading | **Always use remote** |
+
+**Benefits:**
+- **Offline Development**: Work without internet connection after initial download
+- **Faster Builds**: No remote fetching on each build when using 'once' mode
+- **Version Control**: Commit downloaded schemas to track API changes
+- **Network Reliability**: Fallback to cached schema if remote is unavailable
+
+**How it works:**
+- **'once' mode (recommended)**: Downloads schema only if file doesn't exist, then uses cached version
+- **'always' mode**: Checks for schema changes on every build using hash comparison
+- **'manual' mode**: User manages schema files manually, no automatic downloading
+
+**File locations:**
+- Default: `.nitro/graphql/schemas/[serviceName].graphql`
+- Custom: Use `downloadPath` option to specify your preferred location
+
+### Usage
+
+#### 1. Create External Service Queries
+
+```graphql
+<!-- app/graphql/external/countries/countries.graphql -->
+query GetCountries {
+  countries {
+    code
+    name
+    emoji
+    continent {
+      name
+    }
+  }
+}
+
+query GetCountry($code: ID!) {
+  country(code: $code) {
+    code
+    name
+    capital
+    currency
+  }
+}
+```
+
+#### 2. Use Generated SDKs
+
+```typescript
+// Import from centralized index
+import { $sdk, $countriesSdk, $githubSdk } from '~/app/graphql'
+
+// Or import directly from service folders
+import { $countriesSdk } from '~/app/graphql/countries/ofetch'
+
+// Use in components
+const countries = await $countriesSdk.GetCountries()
+const country = await $countriesSdk.GetCountry({ code: 'US' })
+
+// Your main service still works
+const users = await $sdk.GetUsers()
+```
+
+#### 3. Folder Structure
+
+After configuration, your project structure becomes:
+
+```
+app/graphql/
+├── index.ts                    # Centralized exports (auto-generated)
+├── default/                    # Your main GraphQL service
+│   ├── ofetch.ts              # Main service client
+│   └── sdk.ts                 # Main service SDK
+├── countries/                  # External countries service
+│   ├── ofetch.ts              # Countries service client  
+│   └── sdk.ts                 # Countries service SDK
+├── github/                     # External GitHub service
+│   ├── ofetch.ts              # GitHub service client
+│   └── sdk.ts                 # GitHub service SDK
+└── external/                   # Your external service queries
+    ├── countries/
+    │   └── countries.graphql
+    └── github/
+        └── repositories.graphql
+```
+
+#### 4. TypeScript Support
+
+Each service gets its own type definitions:
+
+```typescript
+// Types are automatically generated and available
+import type { GetCountriesQuery } from '#graphql/client/countries'
+import type { GetUsersQuery } from '#graphql/client'
+
+const handleCountries = (countries: GetCountriesQuery) => {
+  // Fully typed countries data
+}
+```
+
+### Service Configuration Options
+
+| Option | Type | Required | Description |
+|--------|------|----------|-------------|
+| `name` | `string` | ✅ | Unique service name (used for folder/file names) |
+| `schema` | `string` \| `string[]` | ✅ | GraphQL schema URL or file path |
+| `endpoint` | `string` | ✅ | GraphQL endpoint URL for queries |
+| `documents` | `string[]` | ❌ | Glob patterns for GraphQL query files |
+| `headers` | `Record<string, string>` \| `() => Record<string, string>` | ❌ | Custom headers for schema introspection and queries |
+| `codegen.client` | `CodegenClientConfig` | ❌ | Custom codegen configuration for client types |
+| `codegen.clientSDK` | `GenericSdkConfig` | ❌ | Custom codegen configuration for SDK generation |
+
+## 🛠️ GraphQL Config (Optional but Recommended)
+
+To enable GraphQL language features in your IDE (autocompletion, validation, go-to definition), create a `graphql.config.ts` file in your project root:
+
+### For Single Service (Main GraphQL Server Only)
+
+```typescript
+// graphql.config.ts
+import type { IGraphQLConfig } from 'graphql-config'
+
+export default <IGraphQLConfig> {
+  schema: ['./.nuxt/graphql/schema.graphql'],
+  documents: ['./app/graphql/**/*.{graphql,js,ts,jsx,tsx}'],
+  exclude: ['./app/graphql/external/**/*'] // Exclude external service documents
+}
+```
+
+### For Multi-Service Setup
+
+```typescript
+// graphql.config.ts
+import type { IGraphQLConfig } from 'graphql-config'
+
+export default <IGraphQLConfig> {
+  projects: {
+    // Main GraphQL server
+    default: {
+      schema: ['./.nuxt/graphql/schema.graphql'],
+      documents: ['./app/graphql/default/**/*.{graphql,js,ts,jsx,tsx}']
+    },
+    // External services
+    github: {
+      schema: [
+        // Use downloaded schema if available, otherwise use remote
+        './.nuxt/graphql/schemas/github.graphql',
+        // Fallback to remote if local doesn't exist
+        'https://docs.github.com/public/schema.docs.graphql'
+      ],
+      documents: ['./app/graphql/external/github/**/*.graphql']
+    },
+    countries: {
+      schema: ['./.nuxt/graphql/schemas/countries.graphql'],
+      documents: ['./app/graphql/external/countries/**/*.graphql']
+    }
+  }
+}
+```
+
+### Schema Paths for Different Download Modes
+
+- **Downloaded schemas**: `./.nuxt/graphql/schemas/[serviceName].graphql`
+- **Custom download path**: Use your `downloadPath` configuration
+- **Remote fallback**: Include remote URL as second option
+
+This configuration enables:
+- 🎯 **Service-specific validation**: Each GraphQL service gets its own validation rules
+- 🚀 **IDE autocompletion**: Full IntelliSense for queries and mutations
+- ✅ **Real-time validation**: Catch GraphQL errors while typing
+- 🔍 **Go-to definition**: Navigate to type definitions across services
+
 ## 🛠️ VS Code Extensions
 
 For the best development experience with GraphQL, install these recommended VS Code extensions:

package/dist/ecosystem/nuxt.d.ts

@@ -1,7 +1,7 @@
-import * as _nuxt_schema0 from "@nuxt/schema";
+import * as _nuxt_schema3 from "@nuxt/schema";
 
 //#region src/ecosystem/nuxt.d.ts
 interface ModuleOptions {}
-declare const _default: _nuxt_schema0.NuxtModule<ModuleOptions, ModuleOptions, false>;
+declare const _default: _nuxt_schema3.NuxtModule<ModuleOptions, ModuleOptions, false>;
 //#endregion
 export { ModuleOptions, _default as default };

package/dist/ecosystem/nuxt.js

@@ -15,11 +15,19 @@ var nuxt_default = defineNuxtModule({
 			options.tsConfig.compilerOptions ??= {};
 			options.tsConfig.compilerOptions.paths ??= {};
 			options.tsConfig.compilerOptions.paths["#graphql/client"] = ["./types/nitro-graphql-client.d.ts"];
+			const externalServices$1 = nuxt.options.nitro?.graphql?.externalServices || [];
+			for (const service of externalServices$1) {
+				options.references.push({ path: `types/nitro-graphql-client-${service.name}.d.ts` });
+				options.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [`./types/nitro-graphql-client-${service.name}.d.ts`];
+			}
 			options.tsConfig.include = options.tsConfig.include || [];
 			options.tsConfig.include.push("./types/nitro-graphql-client.d.ts");
+			for (const service of externalServices$1) options.tsConfig.include.push(`./types/nitro-graphql-client-${service.name}.d.ts`);
 		});
 		nuxt.options.alias = nuxt.options.alias || {};
 		nuxt.options.alias["#graphql/client"] = join(nuxt.options.buildDir, "types/nitro-graphql-client.d.ts");
+		const externalServices = nuxt.options.nitro?.graphql?.externalServices || [];
+		for (const service of externalServices) nuxt.options.alias[`#graphql/client/${service.name}`] = join(nuxt.options.buildDir, `types/nitro-graphql-client-${service.name}.d.ts`);
 		nuxt.hook("imports:dirs", (dirs) => {
 			dirs.push(resolve(nuxt.options.srcDir, "graphql"));
 		});

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { StandardSchemaV1 } from "./types/standard-schema.js";
-import { CodegenClientConfig, CodegenServerConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions } from "./types/index.js";
-import * as nitropack3 from "nitropack";
+import { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, GenImport, GenericSdkConfig, NitroGraphQLOptions } from "./types/index.js";
+import * as nitropack2 from "nitropack";
 
 //#region src/index.d.ts
-declare const _default: nitropack3.NitroModule;
+declare const _default: nitropack2.NitroModule;
 //#endregion
-export { CodegenClientConfig, CodegenServerConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, StandardSchemaV1, _default as default };
+export { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, GenImport, GenericSdkConfig, NitroGraphQLOptions, StandardSchemaV1, _default as default };

package/dist/index.js

@@ -1,8 +1,8 @@
-import { relativeWithDot, scanDirectives, scanDocs, scanResolvers, scanSchemas } from "./utils/index.js";
+import { generateDirectiveSchemas } from "./utils/directive-parser.js";
+import { relativeWithDot, scanDirectives, scanDocs, scanResolvers, scanSchemas, validateExternalServices } from "./utils/index.js";
 import { clientTypeGeneration, serverTypeGeneration } from "./utils/type-generation.js";
 import { rollupConfig } from "./rollup.js";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { watch } from "chokidar";
 import consola from "consola";
@@ -15,6 +15,15 @@ var src_default = defineNitroModule({
 	name: "nitro-graphql",
 	async setup(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?.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}`);
+				throw new Error("Invalid external services configuration");
+			}
+			consola.info(`Configured ${nitro.options.graphql.externalServices.length} external GraphQL services`);
+		}
 		nitro.graphql ||= {
 			buildDir: "",
 			watchDirs: [],
@@ -60,6 +69,13 @@ var src_default = defineNitroModule({
 				break;
 			default:
 		}
+		if (nitro.options.graphql?.externalServices?.length) {
+			for (const service of nitro.options.graphql.externalServices) if (service.documents?.length) for (const pattern of service.documents) {
+				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,
@@ -81,56 +97,7 @@ var src_default = defineNitroModule({
 		nitro.scanResolvers = resolvers;
 		const directives = await scanDirectives(nitro);
 		nitro.scanDirectives = directives;
-		if (directives.length > 0) {
-			const directiveSchemas = [];
-			for (const dir of directives) for (const _imp of dir.imports) {
-				const fileContent = await readFile(dir.specifier, "utf-8");
-				const nameMatch = fileContent.match(/name:\s*['"`](\w+)['"`]/);
-				const locationsMatch = fileContent.match(/locations:\s*\[([\s\S]*?)\]/);
-				const argsMatch = fileContent.match(/args:\s*\{([\s\S]*?)\}\s*,\s*(?:description|transformer)/);
-				if (nameMatch && locationsMatch) {
-					const name = nameMatch[1];
-					const locations = locationsMatch?.[1]?.split(",").map((l) => l.trim().replace(/['"`]/g, "")).filter(Boolean).join(" | ") || "";
-					let args = "";
-					if (argsMatch && argsMatch[1] && argsMatch[1].trim()) {
-						const argDefs = [];
-						const argMatches = argsMatch[1].matchAll(/(\w+):\s*\{([^}]+)\}/g);
-						for (const argMatch of argMatches) {
-							const argName = argMatch[1];
-							const argBody = argMatch[2];
-							const typeMatch = argBody?.match(/type:\s*['"`](\[[\w!]+\]|\w+)['"`]/);
-							const type = typeMatch ? typeMatch[1] : "String";
-							const defaultMatch = argBody?.match(/defaultValue:\s*(['"`]([^'"`]+)['"`]|(\d+)|true|false)/);
-							let defaultValue = "";
-							if (defaultMatch) {
-								const value = defaultMatch[2] || defaultMatch[3] || defaultMatch[1]?.replace(/['"`]/g, "");
-								if (type === "String") defaultValue = ` = "${value}"`;
-								else if (type === "Int" || type === "Float") defaultValue = ` = ${value}`;
-								else if (type === "Boolean") defaultValue = ` = ${value}`;
-							}
-							argDefs.push(`${argName}: ${type}${defaultValue}`);
-						}
-						if (argDefs.length > 0) args = `(${argDefs.join(", ")})`;
-					}
-					directiveSchemas.push(`directive @${name}${args} on ${locations}`);
-				}
-			}
-			if (directiveSchemas.length > 0) {
-				const directivesPath = resolve(nitro.graphql.serverDir, "_directives.graphql");
-				const content = `# WARNING: This file is auto-generated by nitro-graphql
-# Do not modify this file directly. It will be overwritten.
-# To define custom directives, create .directive.ts files using defineDirective()
-
-${directiveSchemas.join("\n\n")}`;
-				let shouldWrite = true;
-				if (existsSync(directivesPath)) {
-					const existingContent = readFileSync(directivesPath, "utf-8");
-					shouldWrite = existingContent !== content;
-				}
-				if (shouldWrite) writeFileSync(directivesPath, content, "utf-8");
-				if (!nitro.scanSchemas.includes(directivesPath)) nitro.scanSchemas.push(directivesPath);
-			}
-		}
+		await generateDirectiveSchemas(nitro, directives);
 		nitro.hooks.hook("dev:start", async () => {
 			const schemas$1 = await scanSchemas(nitro);
 			nitro.scanSchemas = schemas$1;
@@ -138,56 +105,7 @@ ${directiveSchemas.join("\n\n")}`;
 			nitro.scanResolvers = resolvers$1;
 			const directives$1 = await scanDirectives(nitro);
 			nitro.scanDirectives = directives$1;
-			if (directives$1.length > 0) {
-				const directiveSchemas = [];
-				for (const dir of directives$1) for (const _imp of dir.imports) {
-					const fileContent = await readFile(dir.specifier, "utf-8");
-					const nameMatch = fileContent.match(/name:\s*['"`](\w+)['"`]/);
-					const locationsMatch = fileContent.match(/locations:\s*\[([\s\S]*?)\]/);
-					const argsMatch = fileContent.match(/args:\s*\{([\s\S]*?)\}\s*,\s*(?:description|transformer)/);
-					if (nameMatch && locationsMatch) {
-						const name = nameMatch[1];
-						const locations = locationsMatch?.[1]?.split(",").map((l) => l.trim().replace(/['"`]/g, "")).filter(Boolean).join(" | ") || "";
-						let args = "";
-						if (argsMatch && argsMatch[1] && argsMatch[1].trim()) {
-							const argDefs = [];
-							const argMatches = argsMatch[1].matchAll(/(\w+):\s*\{([^}]+)\}/g);
-							for (const argMatch of argMatches) {
-								const argName = argMatch[1];
-								const argBody = argMatch[2];
-								const typeMatch = argBody?.match(/type:\s*['"`](\[?\w+!?\]?)['"`]/);
-								const type = typeMatch ? typeMatch[1] : "String";
-								const defaultMatch = argBody?.match(/defaultValue:\s*(['"`]([^'"`]+)['"`]|(\d+)|true|false)/);
-								let defaultValue = "";
-								if (defaultMatch) {
-									const value = defaultMatch[2] || defaultMatch[3] || defaultMatch[1]?.replace(/['"`]/g, "");
-									if (type === "String") defaultValue = ` = "${value}"`;
-									else if (type === "Int" || type === "Float") defaultValue = ` = ${value}`;
-									else if (type === "Boolean") defaultValue = ` = ${value}`;
-								}
-								argDefs.push(`${argName}: ${type}${defaultValue}`);
-							}
-							if (argDefs.length > 0) args = `(${argDefs.join(", ")})`;
-						}
-						directiveSchemas.push(`directive @${name}${args} on ${locations}`);
-					}
-				}
-				if (directiveSchemas.length > 0) {
-					const directivesPath = resolve(nitro.graphql.serverDir, "_directives.graphql");
-					const content = `# WARNING: This file is auto-generated by nitro-graphql
-# Do not modify this file directly. It will be overwritten.
-# To define custom directives, create .directive.ts files using defineDirective()
-
-${directiveSchemas.join("\n\n")}`;
-					let shouldWrite = true;
-					if (existsSync(directivesPath)) {
-						const existingContent = readFileSync(directivesPath, "utf-8");
-						shouldWrite = existingContent !== content;
-					}
-					if (shouldWrite) writeFileSync(directivesPath, content, "utf-8");
-					if (!nitro.scanSchemas.includes(directivesPath)) nitro.scanSchemas.push(directivesPath);
-				}
-			}
+			await generateDirectiveSchemas(nitro, directives$1);
 			const docs$1 = await scanDocs(nitro);
 			nitro.scanDocuments = docs$1;
 		});
@@ -258,8 +176,14 @@ ${directiveSchemas.join("\n\n")}`;
 			types.tsConfig.compilerOptions.paths["#graphql/server"] = [relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-server.d.ts"))];
 			types.tsConfig.compilerOptions.paths["#graphql/client"] = [relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-client.d.ts"))];
 			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) types.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [relativeWithDot(tsconfigDir, join(typesDir, `nitro-graphql-client-${service.name}.d.ts`))];
 			types.tsConfig.include = types.tsConfig.include || [];
 			types.tsConfig.include.push(relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-server.d.ts")), relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-client.d.ts")), relativeWithDot(tsconfigDir, join(typesDir, "graphql.d.ts")));
+			if (nitro.options.graphql?.externalServices?.length) for (const service of nitro.options.graphql.externalServices) types.tsConfig.include.push(relativeWithDot(tsconfigDir, join(typesDir, `nitro-graphql-client-${service.name}.d.ts`)));
+		});
+		if (nitro.options.framework?.name === "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 (!existsSync(join(nitro.options.rootDir, "graphql.config.ts"))) {
 			const schemaPath = relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.buildDir, "schema.graphql"));

package/dist/rollup.js

@@ -1,7 +1,7 @@
 import { getImportId, scanGraphql } from "./utils/index.js";
 import { clientTypeGeneration, serverTypeGeneration } from "./utils/type-generation.js";
-import { readFile } from "node:fs/promises";
 import { resolve } from "pathe";
+import { readFile } from "node:fs/promises";
 import { parse } from "graphql";
 import { genImport } from "knitwork";