nitro-graphql 1.2.1 → 1.2.3

package/README.md

@@ -30,7 +30,6 @@
 - 🔄 **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
@@ -196,10 +195,6 @@ 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)
@@ -634,90 +629,6 @@ 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>
 
@@ -844,75 +755,6 @@ 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_schema1 from "@nuxt/schema";
+import * as _nuxt_schema0 from "@nuxt/schema";
 
 //#region src/ecosystem/nuxt.d.ts
 interface ModuleOptions {}
-declare const _default: _nuxt_schema1.NuxtModule<ModuleOptions, ModuleOptions, false>;
+declare const _default: _nuxt_schema0.NuxtModule<ModuleOptions, ModuleOptions, false>;
 //#endregion
 export { ModuleOptions, _default as default };

package/dist/ecosystem/nuxt.js

@@ -1,3 +1,4 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join, resolve } from "pathe";
 import { defineNuxtModule } from "@nuxt/kit";
 
@@ -31,6 +32,27 @@ var nuxt_default = defineNuxtModule({
 		nuxt.hook("imports:dirs", (dirs) => {
 			dirs.push(resolve(nuxt.options.srcDir, "graphql"));
 		});
+		nuxt.hook("nitro:config", () => {
+			const clientDir = join(nuxt.options.buildDir, "graphql");
+			const appGraphqlDir = resolve(nuxt.options.rootDir, "app/graphql");
+			const hasAppGraphqlDir = existsSync(appGraphqlDir);
+			if (!hasAppGraphqlDir) {
+				const defaultDir = join(clientDir, "default");
+				if (!existsSync(defaultDir)) mkdirSync(defaultDir, { recursive: true });
+				const sampleQueryFile = join(defaultDir, "queries.graphql");
+				if (!existsSync(sampleQueryFile)) writeFileSync(sampleQueryFile, `# Example GraphQL queries
+# Add your GraphQL queries here
+
+# query GetUser($id: ID!) {
+#   user(id: $id) {
+#     id
+#     name
+#     email
+#   }
+# }
+`, "utf-8");
+			}
+		});
 	}
 });
 

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

package/dist/index.js

@@ -1,5 +1,4 @@
-import { generateDirectiveSchemas } from "./utils/directive-parser.js";
-import { relativeWithDot, scanDirectives, scanDocs, scanResolvers, scanSchemas, validateExternalServices } from "./utils/index.js";
+import { relativeWithDot, 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";
@@ -80,7 +79,7 @@ var src_default = defineNitroModule({
 		const watcher = watch(watchDirs, {
 			persistent: true,
 			ignoreInitial: true,
-			ignored: [...nitro.options.ignore, "**/server/graphql/_directives.graphql"]
+			ignored: nitro.options.ignore
 		}).on("all", async (event, path) => {
 			if (path.endsWith(".graphql") || path.endsWith(".gql")) await clientTypeGeneration(nitro);
 		});
@@ -96,17 +95,11 @@ 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;
 		});
@@ -149,8 +142,7 @@ var src_default = defineNitroModule({
 					"defineSubscription",
 					"defineType",
 					"defineGraphQLConfig",
-					"defineSchema",
-					"defineDirective"
+					"defineSchema"
 				]
 			});
 		}
@@ -246,23 +238,6 @@ declare module 'h3' {
 			consola.warn("nitro-graphql: Found context.d.ts file. Please rename it to context.ts for the new structure.");
 			consola.info("The context file should now be context.ts instead of context.d.ts");
 		}
-		if (nitro.options.framework.name === "nuxt") {
-			if (!existsSync(nitro.graphql.clientDir)) mkdirSync(nitro.graphql.clientDir, { recursive: true });
-			const defaultDir = join(nitro.graphql.clientDir, "default");
-			if (!existsSync(defaultDir)) mkdirSync(defaultDir, { recursive: true });
-			const sampleQueryFile = join(defaultDir, "queries.graphql");
-			if (!existsSync(sampleQueryFile)) writeFileSync(sampleQueryFile, `# Example GraphQL queries
-# Add your GraphQL queries here
-
-# query GetUser($id: ID!) {
-#   user(id: $id) {
-#     id
-#     name
-#     email
-#   }
-# }
-`, "utf-8");
-		}
 	}
 });
 

package/dist/rollup.js

@@ -9,7 +9,6 @@ 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 || [];
@@ -86,29 +85,6 @@ 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 h36 from "h3";
+import * as h31 from "h3";
 
 //#region src/routes/apollo-server.d.ts
-declare const _default: h36.EventHandler<h36.EventHandlerRequest, any>;
+declare const _default: h31.EventHandler<h31.EventHandlerRequest, any>;
 //#endregion
 export { _default as default };

package/dist/routes/apollo-server.js

@@ -2,27 +2,21 @@ 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$1) => schema$1.def).join("\n\n");
+		const mergedSchemas = schemas.map((schema) => schema.def).join("\n\n");
 		const typeDefs = mergeTypeDefs([mergedSchemas]);
 		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
-		let schema = makeExecutableSchema({
+		return {
 			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;
@@ -31,9 +25,10 @@ function createMergedSchema() {
 let apolloServer = null;
 function createApolloServer() {
 	if (!apolloServer) {
-		const schema = createMergedSchema();
+		const { typeDefs, resolvers: mergedResolvers } = createMergedSchema();
 		apolloServer = new ApolloServer(defu({
-			schema,
+			typeDefs,
+			resolvers: mergedResolvers,
 			introspection: true,
 			plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })]
 		}, importedConfig));

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

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

package/dist/routes/graphql-yoga.js

@@ -1,12 +1,10 @@
 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 { createYoga } from "graphql-yoga";
+import { createSchema, createYoga } from "graphql-yoga";
 
 //#region src/routes/graphql-yoga.ts
 const apolloSandboxHtml = `<!DOCTYPE html>
@@ -28,17 +26,13 @@ new window.EmbeddedSandbox({
 </html>`;
 function createMergedSchema() {
 	try {
-		const mergedSchemas = schemas.map((schema$1) => schema$1.def).join("\n\n");
+		const mergedSchemas = schemas.map((schema) => schema.def).join("\n\n");
 		const typeDefs = mergeTypeDefs([mergedSchemas]);
 		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
-		let schema = makeExecutableSchema({
+		return createSchema({
 			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 h34 from "h3";
+import * as h36 from "h3";
 
 //#region src/routes/health.d.ts
-declare const _default: h34.EventHandler<h34.EventHandlerRequest, Promise<{
+declare const _default: h36.EventHandler<h36.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' | 'directive';
+  type: 'resolver' | 'query' | 'mutation' | 'type' | 'subscription';
 }
 interface GenImport {
   specifier: string;
@@ -32,7 +32,6 @@ declare module 'nitropack/types' {
     scanSchemas: string[];
     scanDocuments: string[];
     scanResolvers: GenImport[];
-    scanDirectives: GenImport[];
     graphql: {
       buildDir: string;
       watchDirs: string[];

package/dist/utils/client-codegen.js

@@ -57,23 +57,23 @@ async function loadExternalSchema(service, buildDir) {
 		if (service.downloadSchema && buildDir) {
 			const defaultPath = resolve(buildDir, "graphql", "schemas", `${service.name}.graphql`);
 			const schemaFilePath = service.downloadPath ? resolve(service.downloadPath) : defaultPath;
-			if (existsSync(schemaFilePath)) {
-				consola$1.info(`[graphql:${service.name}] Loading schema from local file: ${schemaFilePath}`);
-				try {
-					const result$1 = loadSchemaSync([schemaFilePath], { loaders: [new GraphQLFileLoader()] });
-					consola$1.info(`[graphql:${service.name}] External schema loaded successfully from local file`);
-					return result$1;
-				} catch (localError) {
-					consola$1.warn(`[graphql:${service.name}] Failed to load local schema, falling back to remote:`, localError);
-				}
+			if (existsSync(schemaFilePath)) try {
+				const result$1 = loadSchemaSync([schemaFilePath], { loaders: [new GraphQLFileLoader()] });
+				return result$1;
+			} catch {
+				consola$1.warn(`[graphql:${service.name}] Cached schema invalid, loading from source`);
 			}
 		}
-		consola$1.info(`[graphql:${service.name}] Loading external schema from: ${schemas.join(", ")}`);
+		const hasUrls = schemas.some((schema) => isUrl(schema));
+		const hasLocalFiles = schemas.some((schema) => !isUrl(schema));
+		const loaders = [];
+		if (hasLocalFiles) loaders.push(new GraphQLFileLoader());
+		if (hasUrls) loaders.push(new UrlLoader());
+		if (loaders.length === 0) throw new Error("No appropriate loaders found for schema sources");
 		const result = loadSchemaSync(schemas, {
-			loaders: [new GraphQLFileLoader(), new UrlLoader()],
+			loaders,
 			...Object.keys(headers).length > 0 && { headers }
 		});
-		consola$1.info(`[graphql:${service.name}] External schema loaded successfully`);
 		return result;
 	} catch (error) {
 		consola$1.error(`[graphql:${service.name}] Failed to load external schema:`, error);
@@ -81,6 +81,12 @@ async function loadExternalSchema(service, buildDir) {
 	}
 }
 /**
+* Check if a path is a URL (http/https)
+*/
+function isUrl(path) {
+	return path.startsWith("http://") || path.startsWith("https://");
+}
+/**
 * Download and save schema from external service
 */
 async function downloadAndSaveSchema(service, buildDir) {
@@ -91,12 +97,14 @@ async function downloadAndSaveSchema(service, buildDir) {
 	try {
 		const headers = typeof service.headers === "function" ? service.headers() : service.headers || {};
 		const schemas = Array.isArray(service.schema) ? service.schema : [service.schema];
+		const hasUrlSchemas = schemas.some((schema) => isUrl(schema));
+		const hasLocalSchemas = schemas.some((schema) => !isUrl(schema));
 		let shouldDownload = false;
 		const fileExists = existsSync(schemaFilePath);
 		if (downloadMode === "always") {
 			shouldDownload = true;
-			if (fileExists) try {
-				const remoteSchema = loadSchemaSync(schemas, {
+			if (fileExists && hasUrlSchemas) try {
+				const remoteSchema = loadSchemaSync(schemas.filter(isUrl), {
 					loaders: [new UrlLoader()],
 					...Object.keys(headers).length > 0 && { headers }
 				});
@@ -112,24 +120,48 @@ async function downloadAndSaveSchema(service, buildDir) {
 				consola$1.warn(`[graphql:${service.name}] Unable to compare with remote schema, updating local cache`);
 				shouldDownload = true;
 			}
-		} else if (downloadMode === true || downloadMode === "once") {
-			shouldDownload = !fileExists;
-			if (fileExists) consola$1.info(`[graphql:${service.name}] Using cached schema from: ${schemaFilePath}`);
-		}
+			else if (fileExists && hasLocalSchemas) {
+				const localFiles = schemas.filter((schema) => !isUrl(schema));
+				let sourceIsNewer = false;
+				for (const localFile of localFiles) if (existsSync(localFile)) {
+					const { statSync } = await import("node:fs");
+					const sourceStats = statSync(localFile);
+					const cachedStats = statSync(schemaFilePath);
+					if (sourceStats.mtime > cachedStats.mtime) {
+						sourceIsNewer = true;
+						break;
+					}
+				}
+				if (!sourceIsNewer) shouldDownload = false;
+			}
+		} else if (downloadMode === true || downloadMode === "once") shouldDownload = !fileExists;
 		if (shouldDownload) {
-			consola$1.info(`[graphql:${service.name}] Downloading schema to: ${schemaFilePath}`);
-			const schema = loadSchemaSync(schemas, {
-				loaders: [new UrlLoader()],
-				...Object.keys(headers).length > 0 && { headers }
-			});
-			const schemaString = printSchemaWithDirectives(schema);
-			mkdirSync(dirname(schemaFilePath), { recursive: true });
-			writeFileSync(schemaFilePath, schemaString, "utf-8");
-			consola$1.success(`[graphql:${service.name}] Schema downloaded and saved successfully`);
+			if (hasUrlSchemas && hasLocalSchemas) {
+				const schema = loadSchemaSync(schemas, {
+					loaders: [new GraphQLFileLoader(), new UrlLoader()],
+					...Object.keys(headers).length > 0 && { headers }
+				});
+				const schemaString = printSchemaWithDirectives(schema);
+				mkdirSync(dirname(schemaFilePath), { recursive: true });
+				writeFileSync(schemaFilePath, schemaString, "utf-8");
+			} else if (hasUrlSchemas) {
+				const schema = loadSchemaSync(schemas, {
+					loaders: [new UrlLoader()],
+					...Object.keys(headers).length > 0 && { headers }
+				});
+				const schemaString = printSchemaWithDirectives(schema);
+				mkdirSync(dirname(schemaFilePath), { recursive: true });
+				writeFileSync(schemaFilePath, schemaString, "utf-8");
+			} else if (hasLocalSchemas) {
+				const schema = loadSchemaSync(schemas, { loaders: [new GraphQLFileLoader()] });
+				const schemaString = printSchemaWithDirectives(schema);
+				mkdirSync(dirname(schemaFilePath), { recursive: true });
+				writeFileSync(schemaFilePath, schemaString, "utf-8");
+			}
 		}
 		return schemaFilePath;
 	} catch (error) {
-		consola$1.error(`[graphql:${service.name}] Failed to download schema:`, error);
+		consola$1.error(`[graphql:${service.name}] Failed to download/copy schema:`, error);
 		return void 0;
 	}
 }
@@ -143,13 +175,11 @@ async function loadGraphQLDocuments(patterns) {
 	}
 }
 async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, outputPath, serviceName) {
-	if (docs.length === 0) {
-		const serviceLabel$1 = serviceName ? `:${serviceName}` : "";
-		consola$1.info(`[graphql${serviceLabel$1}] No client GraphQL files found. Skipping client type generation.`);
+	if (docs.length === 0 && !serviceName) {
+		consola$1.info("No client GraphQL files found. Skipping client type generation.");
 		return false;
 	}
 	const serviceLabel = serviceName ? `:${serviceName}` : "";
-	consola$1.info(`[graphql${serviceLabel}] Found ${docs.length} client GraphQL documents`);
 	const defaultConfig = {
 		emitLegacyCommonJSImports: false,
 		useTypeImports: true,
@@ -178,6 +208,48 @@ async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, ou
 	const mergedConfig = defu$1(defaultConfig, config);
 	const mergedSdkConfig = defu$1(mergedConfig, sdkConfig);
 	try {
+		if (docs.length === 0) {
+			const output$1 = await codegen({
+				filename: outputPath || "client-types.generated.ts",
+				schema: parse(printSchemaWithDirectives(schema)),
+				documents: [],
+				config: mergedConfig,
+				plugins: [{ pluginContent: {} }, { typescript: {} }],
+				pluginMap: {
+					pluginContent: { plugin: pluginContent },
+					typescript: { plugin }
+				}
+			});
+			const sdkContent$1 = `// THIS FILE IS GENERATED, DO NOT EDIT!
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+
+import type { GraphQLResolveInfo } from 'graphql'
+export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> }
+
+export interface Requester<C = {}, E = unknown> {
+  <R, V>(doc: string, vars?: V, options?: C): Promise<R> | AsyncIterable<R>
+}
+
+export type Sdk = {
+  request: <R, V = Record<string, any>>(document: string, variables?: V) => Promise<R>
+}
+
+export function getSdk(requester: Requester): Sdk {
+  return {
+    request: <R, V = Record<string, any>>(document: string, variables?: V): Promise<R> => {
+      return requester<R, V>(document, variables)
+    }
+  }
+}
+`;
+			return {
+				types: output$1,
+				sdk: sdkContent$1
+			};
+		}
 		const output = await codegen({
 			filename: outputPath || "client-types.generated.ts",
 			schema: parse(printSchemaWithDirectives(schema)),

package/dist/utils/define.d.ts

@@ -1,4 +1,3 @@
-import { GraphQLSchema } from "graphql";
 import { ApolloServerOptions } from "@apollo/server";
 import { H3Event } from "h3";
 import { YogaServerOptions } from "graphql-yoga";
@@ -18,55 +17,5 @@ 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 { DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, ResolverQuery, arg, defineDirective, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };
+export { DefineServerConfig, ResolverQuery, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

package/dist/utils/define.js

@@ -20,38 +20,6 @@ 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 { arg, defineDirective, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };
+export { defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

package/dist/utils/index.d.ts

@@ -1,5 +1,4 @@
 import { GenImport } from "../types/index.js";
-import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.js";
 import { Nitro } from "nitropack";
 
 //#region src/utils/index.d.ts
@@ -8,7 +7,7 @@ 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<GenImport[]>;
+declare function scanDirectives(nitro: Nitro): Promise<string[]>;
 declare function scanTypeDefs(nitro: Nitro): Promise<string[]>;
 declare function scanSchemas(nitro: Nitro): Promise<string[]>;
 declare function scanDocs(nitro: Nitro): Promise<string[]>;
@@ -21,4 +20,4 @@ declare function scanExternalServiceDocs(nitro: Nitro, serviceName: string, patt
  */
 declare function validateExternalServices(services: any[]): string[];
 //#endregion
-export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, getImportId, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };
+export { GLOB_SCAN_PATTERN, getImportId, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };

package/dist/utils/index.js

@@ -1,4 +1,3 @@
-import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.js";
 import { join, relative } from "pathe";
 import { readFile } from "node:fs/promises";
 import { hash } from "ohash";
@@ -57,11 +56,6 @@ 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)}`
-					});
 				}
 			}
 		}
@@ -71,28 +65,7 @@ async function scanResolvers(nitro) {
 }
 async function scanDirectives(nitro) {
 	const files = await scanFiles(nitro, "graphql", "**/*.directive.{ts,js}");
-	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;
+	return files.map((f) => f.fullPath);
 }
 async function scanTypeDefs(nitro) {
 	const files = await scanFiles(nitro, "graphql", "**/*.typedef.{ts,js}");
@@ -173,4 +146,4 @@ async function scanDir(nitro, dir, name, globPattern = GLOB_SCAN_PATTERN) {
 }
 
 //#endregion
-export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, getImportId, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };
+export { GLOB_SCAN_PATTERN, getImportId, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };

package/dist/utils/type-generation.js

@@ -116,7 +116,8 @@ async function serverTypeGeneration(app) {
 }
 async function clientTypeGeneration(nitro) {
 	try {
-		await generateMainClientTypes(nitro);
+		const hasServerSchema = nitro.scanSchemas && nitro.scanSchemas.length > 0;
+		if (hasServerSchema) await generateMainClientTypes(nitro);
 		if (nitro.options.graphql?.externalServices?.length) await generateExternalServicesTypes(nitro);
 	} catch (error) {
 		consola.error("Client schema generation error:", error);
@@ -190,8 +191,13 @@ async function generateExternalServicesTypes(nitro) {
 		let loadDocs = [];
 		if (documentPatterns.length > 0) try {
 			loadDocs = await loadGraphQLDocuments(documentPatterns);
+			if (!loadDocs || loadDocs.length === 0) {
+				consola.warn(`[graphql:${service.name}] No GraphQL documents found, skipping service generation`);
+				continue;
+			}
 		} catch (error) {
-			consola.warn(`[graphql:${service.name}] No documents found:`, error);
+			consola.warn(`[graphql:${service.name}] No documents found, skipping service generation:`, error);
+			continue;
 		}
 		const types = await generateExternalClientTypes(service, schema, loadDocs);
 		if (types === false) {

package/package.json

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

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

@@ -1,80 +0,0 @@
-//#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

@@ -1,235 +0,0 @@
-//#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();
-	const parser = new DirectiveParser();
-	for (const dir of directives) for (const _imp of dir.imports) {
-		const fileContent = await readFile(dir.specifier, "utf-8");
-		const directiveDefs = await parser.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 };