nitro-graphql 1.2.3 → 1.3.0

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
 - 🔗 **Multi-Service Support**: Connect to multiple external GraphQL APIs alongside your main server
 
 ## 🎯 Used Projects
@@ -66,13 +67,13 @@ yarn add nitro-graphql graphql-yoga graphql
 **For Apollo Server:**
 ```bash
 # npm
-npm install nitro-graphql @apollo/server graphql
+npm install nitro-graphql @apollo/server @apollo/utils.withrequired @as-integrations/h3 graphql
 
 # pnpm (recommended)
-pnpm add nitro-graphql @apollo/server graphql
+pnpm add nitro-graphql @apollo/server @apollo/utils.withrequired @as-integrations/h3 graphql
 
 # yarn
-yarn add nitro-graphql @apollo/server graphql
+yarn add nitro-graphql @apollo/server @apollo/utils.withrequired @as-integrations/h3 graphql
 ```
 
 ### Step 2: Setup Your Project
@@ -195,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)
@@ -629,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>
 
@@ -755,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>
 

package/dist/graphql/index.js

@@ -0,0 +1 @@
+export {  };

package/dist/graphql/server.js

@@ -0,0 +1 @@
+export {  };

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,4 +1,5 @@
-import { relativeWithDot, scanDocs, scanResolvers, scanSchemas, validateExternalServices } 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, writeFileSync } from "node:fs";
@@ -79,7 +80,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);
 		});
@@ -95,11 +96,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;
 		});
@@ -142,7 +149,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.d.ts

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

package/dist/routes/apollo-server.js

@@ -2,21 +2,31 @@ 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 typeDefs = mergeTypeDefs([mergedSchemas]);
+		const mergedSchemas = schemas.map((schema$1) => schema$1.def).join("\n\n");
+		const typeDefs = mergeTypeDefs([mergedSchemas], {
+			throwOnConflict: true,
+			commentDescriptions: true,
+			sort: true
+		});
 		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 +35,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,21 @@ new window.EmbeddedSandbox({
 </html>`;
 function createMergedSchema() {
 	try {
-		const mergedSchemas = schemas.map((schema) => schema.def).join("\n\n");
-		const typeDefs = mergeTypeDefs([mergedSchemas]);
+		const mergedSchemas = schemas.map((schema$1) => schema$1.def).join("\n\n");
+		const typeDefs = mergeTypeDefs([mergedSchemas], {
+			throwOnConflict: true,
+			commentDescriptions: true,
+			sort: true
+		});
 		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 h36 from "h3";
+import * as h31 from "h3";
 
 //#region src/routes/health.d.ts
-declare const _default: h36.EventHandler<h36.EventHandlerRequest, Promise<{
+declare const _default: h31.EventHandler<h31.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/client-codegen.js

@@ -1,4 +1,3 @@
-import { preset } from "../node_modules/.pnpm/@graphql-codegen_import-types-preset@3.0.1_graphql@16.11.0/node_modules/@graphql-codegen/import-types-preset/esm/index.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { consola as consola$1 } from "consola";
 import { defu as defu$1 } from "defu";
@@ -7,6 +6,7 @@ import { parse } from "graphql";
 import { printSchemaWithDirectives } from "@graphql-tools/utils";
 import { createHash } from "node:crypto";
 import { codegen } from "@graphql-codegen/core";
+import { preset } from "@graphql-codegen/import-types-preset";
 import { plugin } from "@graphql-codegen/typescript";
 import { plugin as plugin$1 } from "@graphql-codegen/typescript-generic-sdk";
 import { plugin as plugin$2 } from "@graphql-codegen/typescript-operations";

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