nitro-graphql 1.1.2 → 1.1.3

package/README.md

@@ -30,6 +30,7 @@
 - 🔄 **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
 
 ## 🚀 Quick Start
 
@@ -181,6 +182,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 +620,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 +830,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>
 

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 * as nitropack1 from "nitropack";
 
 //#region src/index.d.ts
-declare const _default: nitropack3.NitroModule;
+declare const _default: nitropack1.NitroModule;
 //#endregion
 export { CodegenClientConfig, CodegenServerConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, StandardSchemaV1, _default as default };

package/dist/index.js

@@ -1,8 +1,8 @@
+import { generateDirectiveSchemas } from "./utils/directive-parser.js";
 import { relativeWithDot, scanDirectives, scanDocs, scanResolvers, scanSchemas } 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";
@@ -81,56 +81,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 +89,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;
 		});

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";
 

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

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

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

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

package/dist/routes/health.d.ts

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

package/dist/utils/directive-parser.d.ts

@@ -0,0 +1,80 @@
+//#region src/utils/directive-parser.d.ts
+interface ParsedDirective {
+  name: string;
+  locations: string[];
+  args?: Record<string, {
+    type: string;
+    defaultValue?: any;
+  }>;
+  description?: string;
+  isRepeatable?: boolean;
+}
+/**
+ * Clean AST-based directive parser using oxc-parser
+ */
+declare class DirectiveParser {
+  private oxc;
+  init(): Promise<void>;
+  /**
+   * Parse directives from a TypeScript/JavaScript file
+   */
+  parseDirectives(fileContent: string, filePath: string): Promise<ParsedDirective[]>;
+  /**
+   * Extract directive definitions from AST
+   */
+  private extractDirectiveDefinitions;
+  /**
+   * Traverse AST nodes recursively
+   */
+  private traverse;
+  /**
+   * Check if node is a defineDirective call
+   */
+  private isDefineDirectiveCall;
+  /**
+   * Extract directive configuration from defineDirective call
+   */
+  private extractDirectiveFromCall;
+  /**
+   * Extract directive properties from object expression
+   */
+  private extractDirectiveFromObject;
+  /**
+   * Extract string literal value
+   */
+  private extractStringLiteral;
+  /**
+   * Extract boolean literal value
+   */
+  private extractBooleanLiteral;
+  /**
+   * Extract array of strings
+   */
+  private extractStringArray;
+  /**
+   * Extract arguments object
+   */
+  private extractArgsObject;
+  /**
+   * Extract argument configuration
+   */
+  private extractArgConfig;
+  /**
+   * Extract literal value (string, number, boolean)
+   */
+  private extractLiteralValue;
+}
+/**
+ * Generate GraphQL directive schema from parsed directive
+ */
+declare function generateDirectiveSchema(directive: ParsedDirective): string;
+/**
+ * Generate directive schemas file from scanned directives
+ */
+declare function generateDirectiveSchemas(nitro: any, directives: any[]): Promise<void>;
+/**
+ * Singleton instance for reuse
+ */
+declare const directiveParser: DirectiveParser;
+//#endregion
+export { DirectiveParser, ParsedDirective, directiveParser, generateDirectiveSchema, generateDirectiveSchemas };

package/dist/utils/directive-parser.js

@@ -0,0 +1,233 @@
+//#region src/utils/directive-parser.ts
+/**
+* Clean AST-based directive parser using oxc-parser
+*/
+var DirectiveParser = class {
+	oxc;
+	async init() {
+		if (!this.oxc) this.oxc = await import("oxc-parser");
+	}
+	/**
+	* Parse directives from a TypeScript/JavaScript file
+	*/
+	async parseDirectives(fileContent, filePath) {
+		await this.init();
+		try {
+			const result = this.oxc.parseSync(filePath, fileContent, {
+				lang: filePath.endsWith(".ts") ? "ts" : "js",
+				sourceType: "module",
+				astType: "ts"
+			});
+			if (result.errors.length > 0) {
+				console.warn(`Parse errors in ${filePath}:`, result.errors.map((e) => e.message));
+				return [];
+			}
+			return this.extractDirectiveDefinitions(result.program);
+		} catch (error) {
+			console.warn(`Failed to parse ${filePath} with oxc:`, error);
+			return [];
+		}
+	}
+	/**
+	* Extract directive definitions from AST
+	*/
+	extractDirectiveDefinitions(program) {
+		const directives = [];
+		this.traverse(program, (node) => {
+			if (this.isDefineDirectiveCall(node)) {
+				const directive = this.extractDirectiveFromCall(node);
+				if (directive) directives.push(directive);
+			}
+		});
+		return directives;
+	}
+	/**
+	* Traverse AST nodes recursively
+	*/
+	traverse(node, visitor) {
+		if (!node || typeof node !== "object") return;
+		visitor(node);
+		for (const key in node) {
+			const child = node[key];
+			if (Array.isArray(child)) child.forEach((item) => this.traverse(item, visitor));
+			else if (child && typeof child === "object") this.traverse(child, visitor);
+		}
+	}
+	/**
+	* Check if node is a defineDirective call
+	*/
+	isDefineDirectiveCall(node) {
+		return node.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "defineDirective" && node.arguments?.length > 0;
+	}
+	/**
+	* Extract directive configuration from defineDirective call
+	*/
+	extractDirectiveFromCall(node) {
+		const arg = node.arguments[0];
+		if (arg?.type !== "ObjectExpression") return null;
+		return this.extractDirectiveFromObject(arg);
+	}
+	/**
+	* Extract directive properties from object expression
+	*/
+	extractDirectiveFromObject(objNode) {
+		let name = "";
+		let locations = [];
+		let args = {};
+		let description;
+		let isRepeatable;
+		for (const prop of objNode.properties || []) {
+			if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+			switch (prop.key.name) {
+				case "name":
+					name = this.extractStringLiteral(prop.value) || "";
+					break;
+				case "locations":
+					locations = this.extractStringArray(prop.value);
+					break;
+				case "args":
+					args = this.extractArgsObject(prop.value);
+					break;
+				case "description":
+					description = this.extractStringLiteral(prop.value);
+					break;
+				case "isRepeatable":
+					isRepeatable = this.extractBooleanLiteral(prop.value);
+					break;
+			}
+		}
+		return name && locations.length > 0 ? {
+			name,
+			locations,
+			args,
+			description,
+			isRepeatable
+		} : null;
+	}
+	/**
+	* Extract string literal value
+	*/
+	extractStringLiteral(node) {
+		if (node?.type === "Literal" && typeof node.value === "string") return node.value;
+		return void 0;
+	}
+	/**
+	* Extract boolean literal value
+	*/
+	extractBooleanLiteral(node) {
+		if (node?.type === "Literal" && typeof node.value === "boolean") return node.value;
+		return void 0;
+	}
+	/**
+	* Extract array of strings
+	*/
+	extractStringArray(node) {
+		if (node?.type !== "ArrayExpression") return [];
+		return (node.elements || []).filter((el) => el?.type === "Literal" && typeof el.value === "string").map((el) => el.value);
+	}
+	/**
+	* Extract arguments object
+	*/
+	extractArgsObject(node) {
+		if (node?.type !== "ObjectExpression") return {};
+		const args = {};
+		for (const prop of node.properties || []) {
+			if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+			const argName = prop.key.name;
+			const argConfig = this.extractArgConfig(prop.value);
+			if (argConfig) args[argName] = argConfig;
+		}
+		return args;
+	}
+	/**
+	* Extract argument configuration
+	*/
+	extractArgConfig(node) {
+		if (node?.type !== "ObjectExpression") return null;
+		let type = "String";
+		let defaultValue;
+		for (const prop of node.properties || []) {
+			if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+			switch (prop.key.name) {
+				case "type":
+					const typeValue = this.extractStringLiteral(prop.value);
+					if (typeValue) type = typeValue;
+					break;
+				case "defaultValue":
+					defaultValue = this.extractLiteralValue(prop.value);
+					break;
+			}
+		}
+		return {
+			type,
+			...defaultValue !== void 0 && { defaultValue }
+		};
+	}
+	/**
+	* Extract literal value (string, number, boolean)
+	*/
+	extractLiteralValue(node) {
+		if (node?.type === "Literal") return node.value;
+		return void 0;
+	}
+};
+/**
+* Generate GraphQL directive schema from parsed directive
+*/
+function generateDirectiveSchema(directive) {
+	let args = "";
+	if (directive.args && Object.keys(directive.args).length > 0) {
+		const argDefs = Object.entries(directive.args).map(([name, arg]) => {
+			let defaultValue = "";
+			if (arg.defaultValue !== void 0) if (typeof arg.defaultValue === "string") defaultValue = ` = "${arg.defaultValue}"`;
+			else defaultValue = ` = ${arg.defaultValue}`;
+			return `${name}: ${arg.type}${defaultValue}`;
+		});
+		args = `(${argDefs.join(", ")})`;
+	}
+	const locations = directive.locations.join(" | ");
+	return `directive @${directive.name}${args} on ${locations}`;
+}
+/**
+* Generate directive schemas file from scanned directives
+*/
+async function generateDirectiveSchemas(nitro, directives) {
+	if (directives.length === 0) return;
+	const { existsSync, readFileSync, writeFileSync } = await import("node:fs");
+	const { readFile } = await import("node:fs/promises");
+	const { resolve } = await import("pathe");
+	const directiveSchemas = [];
+	const seenDirectives = /* @__PURE__ */ new Set();
+	for (const dir of directives) for (const _imp of dir.imports) {
+		const fileContent = await readFile(dir.specifier, "utf-8");
+		const directiveDefs = await directiveParser.parseDirectives(fileContent, dir.specifier);
+		for (const def of directiveDefs) {
+			if (seenDirectives.has(def.name)) continue;
+			seenDirectives.add(def.name);
+			const schema = generateDirectiveSchema(def);
+			directiveSchemas.push(schema);
+		}
+	}
+	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);
+	}
+}
+/**
+* Singleton instance for reuse
+*/
+const directiveParser = new DirectiveParser();
+
+//#endregion
+export { DirectiveParser, directiveParser, generateDirectiveSchema, generateDirectiveSchemas };

package/dist/utils/index.d.ts

@@ -1,4 +1,5 @@
 import { GenImport } from "../types/index.js";
+import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.js";
 import { Nitro } from "nitropack";
 
 //#region src/utils/index.d.ts
@@ -12,4 +13,4 @@ declare function scanTypeDefs(nitro: Nitro): Promise<string[]>;
 declare function scanSchemas(nitro: Nitro): Promise<string[]>;
 declare function scanDocs(nitro: Nitro): Promise<string[]>;
 //#endregion
-export { GLOB_SCAN_PATTERN, getImportId, relativeWithDot, scanDirectives, scanDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs };
+export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, getImportId, relativeWithDot, scanDirectives, scanDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs };

package/dist/utils/index.js

@@ -1,5 +1,6 @@
-import { readFile } from "node:fs/promises";
+import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.js";
 import { join, relative } from "pathe";
+import { readFile } from "node:fs/promises";
 import { hash } from "ohash";
 import { parseAsync } from "oxc-parser";
 import { glob } from "tinyglobby";
@@ -131,4 +132,4 @@ async function scanDir(nitro, dir, name, globPattern = GLOB_SCAN_PATTERN) {
 }
 
 //#endregion
-export { GLOB_SCAN_PATTERN, getImportId, relativeWithDot, scanDirectives, scanDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs };
+export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, getImportId, relativeWithDot, scanDirectives, scanDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nitro-graphql",
   "type": "module",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "GraphQL integration for Nitro",
   "license": "MIT",
   "sideEffects": false,