nitro-graphql 1.1.1 → 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/ecosystem/nuxt.d.ts

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

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

package/dist/index.js

@@ -1,4 +1,5 @@
-import { relativeWithDot, scanDocs, scanResolvers, scanSchemas } from "./utils/index.js";
+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, writeFileSync } from "node:fs";
@@ -62,7 +63,7 @@ var src_default = defineNitroModule({
 		const watcher = watch(watchDirs, {
 			persistent: true,
 			ignoreInitial: true,
-			ignored: nitro.options.ignore
+			ignored: [...nitro.options.ignore, "**/server/graphql/_directives.graphql"]
 		}).on("all", async (event, path) => {
 			if (path.endsWith(".graphql") || path.endsWith(".gql")) await clientTypeGeneration(nitro);
 		});
@@ -78,11 +79,17 @@ var src_default = defineNitroModule({
 		nitro.scanDocuments = docs;
 		const resolvers = await scanResolvers(nitro);
 		nitro.scanResolvers = resolvers;
+		const directives = await scanDirectives(nitro);
+		nitro.scanDirectives = directives;
+		await generateDirectiveSchemas(nitro, directives);
 		nitro.hooks.hook("dev:start", async () => {
 			const schemas$1 = await scanSchemas(nitro);
 			nitro.scanSchemas = schemas$1;
 			const resolvers$1 = await scanResolvers(nitro);
 			nitro.scanResolvers = resolvers$1;
+			const directives$1 = await scanDirectives(nitro);
+			nitro.scanDirectives = directives$1;
+			await generateDirectiveSchemas(nitro, directives$1);
 			const docs$1 = await scanDocs(nitro);
 			nitro.scanDocuments = docs$1;
 		});
@@ -125,7 +132,8 @@ var src_default = defineNitroModule({
 					"defineSubscription",
 					"defineType",
 					"defineGraphQLConfig",
-					"defineSchema"
+					"defineSchema",
+					"defineDirective"
 				]
 			});
 		}

package/dist/rollup.js

@@ -9,6 +9,7 @@ import { genImport } from "knitwork";
 async function rollupConfig(app) {
 	virtualSchemas(app);
 	virtualResolvers(app);
+	virtualDirectives(app);
 	getGraphQLConfig(app);
 	app.hooks.hook("rollup:before", (nitro, rollupConfig$1) => {
 		rollupConfig$1.plugins = rollupConfig$1.plugins || [];
@@ -85,6 +86,29 @@ function virtualResolvers(app) {
 		return code;
 	};
 }
+function virtualDirectives(app) {
+	const getDirectives = () => {
+		const directives = [...app.scanDirectives || []];
+		return directives;
+	};
+	app.options.virtual ??= {};
+	app.options.virtual["#nitro-internal-virtual/server-directives"] = () => {
+		const imports = getDirectives();
+		const importsContent = [...imports.map(({ specifier, imports: imports$1, options }) => {
+			return genImport(specifier, imports$1, options);
+		})];
+		const data = imports.map(({ imports: imports$1 }) => imports$1.map((i) => `{ directive: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n");
+		const content = [
+			"export const directives = [",
+			data,
+			"]",
+			""
+		];
+		content.unshift(...importsContent);
+		const code = content.join("\n");
+		return code;
+	};
+}
 function getGraphQLConfig(app) {
 	const configPath = resolve(app.graphql.serverDir, "config.ts");
 	app.options.virtual ??= {};

package/dist/routes/apollo-server.js

@@ -2,21 +2,27 @@ import { startServerAndCreateH3Handler } from "../utils/apollo.js";
 import defu from "defu";
 import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
 import { importedConfig } from "#nitro-internal-virtual/graphql-config";
+import { directives } from "#nitro-internal-virtual/server-directives";
 import { resolvers } from "#nitro-internal-virtual/server-resolvers";
 import { schemas } from "#nitro-internal-virtual/server-schemas";
 import { ApolloServer } from "@apollo/server";
 import { ApolloServerPluginLandingPageLocalDefault } from "@apollo/server/plugin/landingPage/default";
+import { makeExecutableSchema } from "@graphql-tools/schema";
 
 //#region src/routes/apollo-server.ts
 function createMergedSchema() {
 	try {
-		const mergedSchemas = schemas.map((schema) => schema.def).join("\n\n");
+		const mergedSchemas = schemas.map((schema$1) => schema$1.def).join("\n\n");
 		const typeDefs = mergeTypeDefs([mergedSchemas]);
 		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
-		return {
+		let schema = makeExecutableSchema({
 			typeDefs,
 			resolvers: mergedResolvers
-		};
+		});
+		if (directives && directives.length > 0) {
+			for (const { directive } of directives) if (directive.transformer) schema = directive.transformer(schema);
+		}
+		return schema;
 	} catch (error) {
 		console.error("Schema merge error:", error);
 		throw error;
@@ -25,10 +31,9 @@ function createMergedSchema() {
 let apolloServer = null;
 function createApolloServer() {
 	if (!apolloServer) {
-		const { typeDefs, resolvers: mergedResolvers } = createMergedSchema();
+		const schema = createMergedSchema();
 		apolloServer = new ApolloServer(defu({
-			typeDefs,
-			resolvers: mergedResolvers,
+			schema,
 			introspection: true,
 			plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })]
 		}, importedConfig));

package/dist/routes/graphql-yoga.js

@@ -1,10 +1,12 @@
 import defu from "defu";
 import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
 import { importedConfig } from "#nitro-internal-virtual/graphql-config";
+import { directives } from "#nitro-internal-virtual/server-directives";
 import { resolvers } from "#nitro-internal-virtual/server-resolvers";
 import { schemas } from "#nitro-internal-virtual/server-schemas";
+import { makeExecutableSchema } from "@graphql-tools/schema";
 import { defineEventHandler, toWebRequest } from "h3";
-import { createSchema, createYoga } from "graphql-yoga";
+import { createYoga } from "graphql-yoga";
 
 //#region src/routes/graphql-yoga.ts
 const apolloSandboxHtml = `<!DOCTYPE html>
@@ -26,13 +28,17 @@ new window.EmbeddedSandbox({
 </html>`;
 function createMergedSchema() {
 	try {
-		const mergedSchemas = schemas.map((schema) => schema.def).join("\n\n");
+		const mergedSchemas = schemas.map((schema$1) => schema$1.def).join("\n\n");
 		const typeDefs = mergeTypeDefs([mergedSchemas]);
 		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
-		return createSchema({
+		let schema = makeExecutableSchema({
 			typeDefs,
 			resolvers: mergedResolvers
 		});
+		if (directives && directives.length > 0) {
+			for (const { directive } of directives) if (directive.transformer) schema = directive.transformer(schema);
+		}
+		return schema;
 	} catch (error) {
 		console.error("Schema merge error:", error);
 		throw error;

package/dist/routes/health.d.ts

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

package/dist/types/index.d.ts

@@ -20,7 +20,7 @@ type CodegenClientConfig = TypeScriptPluginConfig & TypeScriptDocumentsPluginCon
 interface IESMImport {
   name: string;
   as?: string;
-  type: 'resolver' | 'query' | 'mutation' | 'type' | 'subscription';
+  type: 'resolver' | 'query' | 'mutation' | 'type' | 'subscription' | 'directive';
 }
 interface GenImport {
   specifier: string;
@@ -32,6 +32,7 @@ declare module 'nitropack/types' {
     scanSchemas: string[];
     scanDocuments: string[];
     scanResolvers: GenImport[];
+    scanDirectives: GenImport[];
     graphql: {
       buildDir: string;
       watchDirs: string[];

package/dist/utils/define.d.ts

@@ -1,3 +1,4 @@
+import { GraphQLSchema } from "graphql";
 import { ApolloServerOptions } from "@apollo/server";
 import { H3Event } from "h3";
 import { YogaServerOptions } from "graphql-yoga";
@@ -17,5 +18,55 @@ declare function defineSubscription(resolvers?: Resolvers['Subscription']): Reso
 declare function defineType(resolvers: Resolvers): Resolvers;
 type DefineServerConfig<T extends NPMConfig = NPMConfig> = T['framework'] extends 'graphql-yoga' ? Partial<YogaServerOptions<H3Event, Partial<H3Event>>> : T['framework'] extends 'apollo-server' ? Partial<ApolloServerOptions<H3Event>> : Partial<YogaServerOptions<H3Event, Partial<H3Event>>> | Partial<ApolloServerOptions<H3Event>>;
 declare function defineGraphQLConfig<T extends NPMConfig = NPMConfig>(config: Partial<DefineServerConfig<T>>): Partial<DefineServerConfig<T>>;
+type DirectiveLocationName = 'QUERY' | 'MUTATION' | 'SUBSCRIPTION' | 'FIELD' | 'FRAGMENT_DEFINITION' | 'FRAGMENT_SPREAD' | 'INLINE_FRAGMENT' | 'VARIABLE_DEFINITION' | 'SCHEMA' | 'SCALAR' | 'OBJECT' | 'FIELD_DEFINITION' | 'ARGUMENT_DEFINITION' | 'INTERFACE' | 'UNION' | 'ENUM' | 'ENUM_VALUE' | 'INPUT_OBJECT' | 'INPUT_FIELD_DEFINITION';
+type GraphQLScalarType = 'String' | 'Int' | 'Float' | 'Boolean' | 'ID' | 'JSON' | 'DateTime';
+type GraphQLBaseType = GraphQLScalarType | (string & {});
+type GraphQLArgumentType = 'String' | 'Int' | 'Float' | 'Boolean' | 'ID' | 'JSON' | 'DateTime' | 'String!' | 'Int!' | 'Float!' | 'Boolean!' | 'ID!' | 'JSON!' | 'DateTime!' | '[String]' | '[String!]' | '[String]!' | '[String!]!' | '[Int]' | '[Int!]' | '[Int]!' | '[Int!]!' | '[Float]' | '[Float!]' | '[Float]!' | '[Float!]!' | '[Boolean]' | '[Boolean!]' | '[Boolean]!' | '[Boolean!]!' | '[ID]' | '[ID!]' | '[ID]!' | '[ID!]!' | '[JSON]' | '[JSON!]' | '[JSON]!' | '[JSON!]!' | '[DateTime]' | '[DateTime!]' | '[DateTime]!' | '[DateTime!]!' | (string & {});
+interface DirectiveArgument<T extends GraphQLArgumentType = GraphQLArgumentType> {
+  /**
+   * GraphQL type for the argument
+   * @example 'String', 'Int!', '[String!]!', 'DateTime', 'JSON'
+   */
+  type: T;
+  defaultValue?: any;
+  description?: string;
+}
+interface DirectiveArg {
+  type: GraphQLArgumentType;
+  defaultValue?: any;
+  description?: string;
+}
+interface DirectiveDefinition {
+  name: string;
+  locations: DirectiveLocationName[];
+  args?: Record<string, DirectiveArg>;
+  description?: string;
+  isRepeatable?: boolean;
+  transformer?: (schema: GraphQLSchema) => GraphQLSchema;
+}
+interface DefineDirectiveConfig {
+  name: string;
+  locations: ReadonlyArray<DirectiveLocationName>;
+  args?: Record<string, {
+    type: GraphQLArgumentType;
+    defaultValue?: any;
+    description?: string;
+  }>;
+  description?: string;
+  isRepeatable?: boolean;
+  transformer?: (schema: GraphQLSchema) => GraphQLSchema;
+}
+/**
+ * Helper function to create directive arguments with proper type inference
+ * @example
+ * args: {
+ *   myArg: arg('String!', { defaultValue: 'hello' })
+ * }
+ */
+declare function arg<T extends GraphQLArgumentType>(type: T, options?: {
+  defaultValue?: any;
+  description?: string;
+}): DirectiveArgument<T>;
+declare function defineDirective(config: DefineDirectiveConfig): DirectiveDefinition;
 //#endregion
-export { DefineServerConfig, ResolverQuery, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };
+export { DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, ResolverQuery, arg, defineDirective, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

package/dist/utils/define.js

@@ -20,6 +20,38 @@ function defineType(resolvers) {
 function defineGraphQLConfig(config) {
 	return config;
 }
+/**
+* Helper function to create directive arguments with proper type inference
+* @example
+* args: {
+*   myArg: arg('String!', { defaultValue: 'hello' })
+* }
+*/
+function arg(type, options) {
+	return {
+		type,
+		...options
+	};
+}
+function defineDirective(config) {
+	const args = config.args ? Object.entries(config.args).map(([name, arg$1]) => {
+		const defaultValue = arg$1.defaultValue !== void 0 ? ` = ${JSON.stringify(arg$1.defaultValue)}` : "";
+		return `${name}: ${arg$1.type}${defaultValue}`;
+	}).join(", ") : "";
+	const argsString = args ? `(${args})` : "";
+	const locations = config.locations.join(" | ");
+	const schemaDefinition = `directive @${config.name}${argsString} on ${locations}`;
+	Object.defineProperty(config, "__schema", {
+		value: schemaDefinition,
+		enumerable: false,
+		configurable: false,
+		writable: false
+	});
+	return {
+		...config,
+		locations: [...config.locations]
+	};
+}
 
 //#endregion
-export { defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };
+export { arg, defineDirective, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

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
@@ -7,9 +8,9 @@ declare function getImportId(p: string, lazy?: boolean): string;
 declare function relativeWithDot(from: string, to: string): string;
 declare function scanGraphql(nitro: Nitro): Promise<string[]>;
 declare function scanResolvers(nitro: Nitro): Promise<GenImport[]>;
-declare function scanDirectives(nitro: Nitro): Promise<string[]>;
+declare function scanDirectives(nitro: Nitro): Promise<GenImport[]>;
 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,3 +1,4 @@
+import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.js";
 import { join, relative } from "pathe";
 import { readFile } from "node:fs/promises";
 import { hash } from "ohash";
@@ -56,6 +57,11 @@ async function scanResolvers(nitro) {
 						type: "subscription",
 						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
 					});
+					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineDirective") exports.imports.push({
+						name: decl.id.name,
+						type: "directive",
+						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+					});
 				}
 			}
 		}
@@ -65,7 +71,28 @@ async function scanResolvers(nitro) {
 }
 async function scanDirectives(nitro) {
 	const files = await scanFiles(nitro, "graphql", "**/*.directive.{ts,js}");
-	return files.map((f) => f.fullPath);
+	const exportName = [];
+	for (const file of files) {
+		const fileContent = await readFile(file.fullPath, "utf-8");
+		const parsed = await parseAsync(file.fullPath, fileContent);
+		const exports = {
+			imports: [],
+			specifier: file.fullPath
+		};
+		for (const node of parsed.program.body) if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "VariableDeclaration") {
+			for (const decl of node.declaration.declarations) if (decl.type === "VariableDeclarator" && decl.init && decl.id.type === "Identifier") {
+				if (decl.init && decl.init.type === "CallExpression") {
+					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineDirective") exports.imports.push({
+						name: decl.id.name,
+						type: "directive",
+						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+					});
+				}
+			}
+		}
+		if (exports.imports.length > 0) exportName.push(exports);
+	}
+	return exportName;
 }
 async function scanTypeDefs(nitro) {
 	const files = await scanFiles(nitro, "graphql", "**/*.typedef.{ts,js}");
@@ -105,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.1",
+  "version": "1.1.3",
   "description": "GraphQL integration for Nitro",
   "license": "MIT",
   "sideEffects": false,