nitro-graphql 2.0.0-beta.3 → 2.0.0-beta.31

package/dist/ecosystem/nuxt.mjs

@@ -0,0 +1,109 @@
+import { getDefaultPaths, getTypesConfig, resolveFilePath } from "../utils/path-resolver.mjs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "pathe";
+import { defineNuxtModule, getLayerDirectories } from "@nuxt/kit";
+
+//#region src/ecosystem/nuxt.ts
+var nuxt_default = defineNuxtModule({
+	meta: {
+		name: "nitro-graphql-nuxt",
+		configKey: "nitro-graphql-nuxt",
+		compatibility: { nuxt: ">=3.16.0" }
+	},
+	setup: async (_options, nuxt) => {
+		nuxt.hooks.hook("prepare:types", (options) => {
+			const mockNitro$1 = { options: {
+				rootDir: nuxt.options.rootDir,
+				buildDir: nuxt.options.buildDir,
+				framework: { name: "nuxt" },
+				graphql: nuxt.options.nitro?.graphql
+			} };
+			const placeholders$1 = getDefaultPaths(mockNitro$1);
+			const typesConfig$1 = getTypesConfig(mockNitro$1);
+			const tsconfigDir = dirname(join(nuxt.options.buildDir, "tsconfig.json"));
+			const relativeWithDot = (from, to) => {
+				const rel = relative(from, to);
+				return rel.startsWith(".") ? rel : `./${rel}`;
+			};
+			const clientTypesPath$1 = resolveFilePath(typesConfig$1.client, typesConfig$1.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders$1);
+			if (clientTypesPath$1) {
+				const relativePath = relativeWithDot(tsconfigDir, clientTypesPath$1);
+				options.references.push({ path: relativePath });
+				options.tsConfig ??= {};
+				options.tsConfig.compilerOptions ??= {};
+				options.tsConfig.compilerOptions.paths ??= {};
+				options.tsConfig.compilerOptions.paths["#graphql/client"] = [relativePath];
+				options.tsConfig.include = options.tsConfig.include || [];
+				options.tsConfig.include.push(relativePath);
+			}
+			const externalServices$1 = nuxt.options.nitro?.graphql?.externalServices || [];
+			for (const service of externalServices$1) {
+				const servicePlaceholders = {
+					...placeholders$1,
+					serviceName: service.name
+				};
+				const externalTypesPath = resolveFilePath(service.paths?.types ?? typesConfig$1.external, typesConfig$1.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", servicePlaceholders);
+				if (externalTypesPath) {
+					const relativePath = relativeWithDot(tsconfigDir, externalTypesPath);
+					options.references.push({ path: relativePath });
+					options.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [relativePath];
+					options.tsConfig.include.push(relativePath);
+				}
+			}
+		});
+		nuxt.options.alias = nuxt.options.alias || {};
+		const mockNitro = { options: {
+			rootDir: nuxt.options.rootDir,
+			buildDir: nuxt.options.buildDir,
+			framework: { name: "nuxt" },
+			graphql: nuxt.options.nitro?.graphql
+		} };
+		const placeholders = getDefaultPaths(mockNitro);
+		const typesConfig = getTypesConfig(mockNitro);
+		const clientTypesPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
+		if (clientTypesPath) nuxt.options.alias["#graphql/client"] = clientTypesPath;
+		const externalServices = nuxt.options.nitro?.graphql?.externalServices || [];
+		for (const service of externalServices) {
+			const servicePlaceholders = {
+				...placeholders,
+				serviceName: service.name
+			};
+			const externalTypesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", servicePlaceholders);
+			if (externalTypesPath) nuxt.options.alias[`#graphql/client/${service.name}`] = externalTypesPath;
+		}
+		nuxt.hook("imports:dirs", (dirs) => {
+			const graphqlServerPath = nuxt.options.nitro?.graphql?.serverDir || resolve(nuxt.options.srcDir, "graphql");
+			dirs.push(graphqlServerPath);
+		});
+		nuxt.hook("nitro:config", async (nitroConfig) => {
+			const clientDir = join(nuxt.options.buildDir, "graphql");
+			const layerDirs = await getLayerDirectories(nuxt);
+			const layerDirectories = layerDirs.map((layer) => layer.root.replace(/\/$/, "")).filter((root) => root !== nuxt.options.rootDir);
+			const layerServerDirs = layerDirs.filter((layer) => layer.root !== `${nuxt.options.rootDir}/`).map((layer) => layer.server?.replace(/\/$/, "")).filter(Boolean);
+			const layerAppDirs = layerDirs.filter((layer) => layer.root !== `${nuxt.options.rootDir}/`).map((layer) => layer.app?.replace(/\/$/, "")).filter(Boolean);
+			if (!nitroConfig.graphql) nitroConfig.graphql = {};
+			nitroConfig.graphql.layerDirectories = layerDirectories;
+			nitroConfig.graphql.layerServerDirs = layerServerDirs;
+			nitroConfig.graphql.layerAppDirs = layerAppDirs;
+			if (!existsSync(resolve(nuxt.options.rootDir, "app/graphql"))) {
+				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");
+			}
+		});
+	}
+});
+
+//#endregion
+export { nuxt_default as default };

package/dist/index.d.mts

@@ -0,0 +1,43 @@
+import { NitroGraphQLOptions } from "./types/index.mjs";
+import { NitroModule } from "nitro/types";
+import { Plugin } from "vite";
+
+//#region src/index.d.ts
+
+/**
+ * Vite plugin to load GraphQL files as strings AND auto-register Nitro module
+ * This prevents Vite from trying to parse .graphql/.gql files as JavaScript
+ * and automatically sets up the nitro-graphql module via the nitro: hook
+ *
+ * @example - Vite usage
+ * ```ts
+ * import { defineConfig } from 'vite'
+ * import { nitro } from 'nitro/vite'
+ * import graphql from 'nitro-graphql'
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     graphql({ framework: 'graphql-yoga' }), // Auto-registers Nitro module
+ *     nitro()
+ *   ]
+ * })
+ * ```
+ *
+ *
+ * @example - Nitro direct usage
+ * ```ts
+ *
+ * import graphql from 'nitro-graphql'
+ *
+ * export default defineConfig({
+ *   modules: [
+ *    graphql({ framework: 'graphql-yoga' }) // Auto-registers Nitro module
+ *   ]
+ * })
+ * ```
+ */
+declare function graphqlModule(options?: NitroGraphQLOptions): Plugin & {
+  nitro?: NitroModule;
+};
+//#endregion
+export { graphqlModule as default };

package/dist/index.mjs

@@ -0,0 +1,63 @@
+import { setupNitroGraphQL } from "./setup.mjs";
+import { readFile } from "node:fs/promises";
+import defu from "defu";
+
+//#region src/index.ts
+/**
+* Vite plugin to load GraphQL files as strings AND auto-register Nitro module
+* This prevents Vite from trying to parse .graphql/.gql files as JavaScript
+* and automatically sets up the nitro-graphql module via the nitro: hook
+*
+* @example - Vite usage
+* ```ts
+* import { defineConfig } from 'vite'
+* import { nitro } from 'nitro/vite'
+* import graphql from 'nitro-graphql'
+*
+* export default defineConfig({
+*   plugins: [
+*     graphql({ framework: 'graphql-yoga' }), // Auto-registers Nitro module
+*     nitro()
+*   ]
+* })
+* ```
+*
+*
+* @example - Nitro direct usage
+* ```ts
+*
+* import graphql from 'nitro-graphql'
+*
+* export default defineConfig({
+*   modules: [
+*    graphql({ framework: 'graphql-yoga' }) // Auto-registers Nitro module
+*   ]
+* })
+* ```
+*/
+function graphqlModule(options) {
+	return {
+		name: "nitro-graphql",
+		enforce: "pre",
+		async load(id) {
+			if (!/\.(?:graphql|gql)$/i.test(id)) return null;
+			try {
+				const content = await readFile(id, "utf-8");
+				return `export default ${JSON.stringify(content)}`;
+			} catch (error) {
+				if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+				throw error;
+			}
+		},
+		nitro: { async setup(nitro) {
+			if (options) nitro.options.graphql = defu(nitro.options.graphql || {}, options);
+			nitro.options.graphql = nitro.options.graphql || {};
+			nitro.options.graphql._vitePlugin = true;
+			await setupNitroGraphQL(nitro);
+		} }
+	};
+}
+var src_default = graphqlModule;
+
+//#endregion
+export { src_default as default };

package/dist/rollup.d.mts

@@ -0,0 +1,12 @@
+import { Nitro } from "nitro/types";
+
+//#region src/rollup.d.ts
+declare function rollupConfig(app: Nitro): Promise<void>;
+declare function virtualSchemas(app: Nitro): void;
+declare function virtualResolvers(app: Nitro): void;
+declare function virtualDirectives(app: Nitro): void;
+declare function getGraphQLConfig(app: Nitro): void;
+declare function virtualModuleConfig(app: Nitro): void;
+declare function virtualDebugInfo(app: Nitro): void;
+//#endregion
+export { getGraphQLConfig, rollupConfig, virtualDebugInfo, virtualDirectives, virtualModuleConfig, virtualResolvers, virtualSchemas };

package/dist/rollup.mjs

@@ -0,0 +1,282 @@
+import { getImportId, scanGraphql } from "./utils/index.mjs";
+import { clientTypeGeneration, serverTypeGeneration } from "./utils/type-generation.mjs";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { resolve } from "pathe";
+import { parse } from "graphql";
+import { genImport } from "knitwork";
+
+//#region src/rollup.ts
+async function rollupConfig(app) {
+	virtualSchemas(app);
+	virtualResolvers(app);
+	virtualDirectives(app);
+	getGraphQLConfig(app);
+	virtualModuleConfig(app);
+	virtualDebugInfo(app);
+	app.hooks.hook("rollup:before", (nitro, rollupConfig$1) => {
+		rollupConfig$1.plugins = rollupConfig$1.plugins || [];
+		const { include = /\.(?:graphql|gql)$/i, exclude, validate = false } = app.options.graphql?.loader || {};
+		if (Array.isArray(rollupConfig$1.plugins)) {
+			rollupConfig$1.plugins.push({
+				name: "nitro-graphql:virtual",
+				resolveId: {
+					order: "pre",
+					filter: { id: /^#nitro-graphql\// },
+					async handler(id, parent, options) {
+						if (id.startsWith("#nitro-graphql/")) return `\0virtual:${id}`;
+						if (parent?.startsWith("\0virtual:#nitro-graphql")) {
+							const runtimeDir = fileURLToPath(new URL("routes", import.meta.url));
+							const internalRes = await this.resolve(id, runtimeDir, {
+								skipSelf: true,
+								...options
+							});
+							if (internalRes) return internalRes;
+						}
+					}
+				},
+				load: {
+					order: "pre",
+					filter: { id: /^\0virtual:#nitro-graphql\// },
+					async handler(id) {
+						if (id.startsWith("\0virtual:#nitro-graphql/")) {
+							const moduleName = id.slice(9);
+							const generator = app.options.virtual?.[moduleName];
+							if (typeof generator === "function") try {
+								return {
+									code: await generator(),
+									moduleType: "js"
+								};
+							} catch (error) {
+								const message = error instanceof Error ? error.message : String(error);
+								this.error(`Failed to generate virtual module ${moduleName}: ${message}`);
+							}
+							else this.error(`No generator function found for virtual module ${moduleName}`);
+						}
+					}
+				}
+			});
+			rollupConfig$1.plugins.push({
+				name: "nitro-graphql",
+				resolveId: {
+					order: "pre",
+					handler(id) {
+						if (/\.(?:graphql|gql)$/i.test(id)) return null;
+					}
+				},
+				load: {
+					order: "pre",
+					async handler(id) {
+						if (exclude?.test?.(id)) return null;
+						if (!include.test(id)) return null;
+						try {
+							const content = await readFile(id, "utf-8");
+							if (validate) parse(content);
+							return `export default ${JSON.stringify(content)}`;
+						} catch (error) {
+							if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
+							const message = error instanceof Error ? error.message : String(error);
+							this.error(`Failed to read GraphQL file ${id}: ${message}`);
+						}
+					}
+				}
+			});
+			if (app.options.dev) rollupConfig$1.plugins.push({
+				name: "nitro-graphql-watcher",
+				buildStart: {
+					order: "pre",
+					async handler() {
+						const graphqlFiles = await scanGraphql(nitro);
+						for (const file of graphqlFiles) this.addWatchFile(file);
+					}
+				}
+			});
+		}
+	});
+	app.hooks.hook("dev:reload", async () => {
+		await serverTypeGeneration(app, { silent: true });
+		await clientTypeGeneration(app, { silent: true });
+	});
+}
+function virtualSchemas(app) {
+	const getSchemas = () => [...app.scanSchemas, ...app.options.graphql?.typedefs ?? []];
+	app.options.virtual ??= {};
+	app.options.virtual["#nitro-graphql/server-schemas"] = () => {
+		try {
+			const imports = getSchemas();
+			if (imports.length === 0) {
+				if (app.options.dev) app.logger.warn("[nitro-graphql] No schemas found. Virtual module will export empty array.");
+				return "export const schemas = []";
+			}
+			const importStatements = imports.map((handler) => `import ${getImportId(handler)} from '${handler}';`);
+			const schemaArray = imports.map((h) => `{ def: ${getImportId(h)} }`);
+			return `
+${importStatements.join("\n")}
+
+export const schemas = [
+${schemaArray.join(",\n")}
+];
+    `;
+		} catch (error) {
+			app.logger.error("[nitro-graphql] Failed to generate virtual schema module:", error);
+			return "export const schemas = []";
+		}
+	};
+}
+function virtualResolvers(app) {
+	const getResolvers = () => [...app.scanResolvers];
+	app.options.virtual ??= {};
+	app.options.virtual["#nitro-graphql/server-resolvers"] = () => {
+		try {
+			const imports = getResolvers();
+			if (imports.length === 0) {
+				if (app.options.dev) app.logger.warn("[nitro-graphql] No resolvers found. Virtual module will export empty array.");
+				return "export const resolvers = []";
+			}
+			const importsContent = [];
+			const invalidImports = [];
+			for (const { specifier, imports: importList, options } of imports) try {
+				if (!importList || importList.length === 0) {
+					invalidImports.push(`${specifier}: No exports found`);
+					continue;
+				}
+				const importCode = genImport(specifier, importList, options);
+				importsContent.push(importCode);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				invalidImports.push(`${specifier}: ${message}`);
+				if (app.options.dev) app.logger.error(`[nitro-graphql] Failed to generate import for ${specifier}:`, error);
+			}
+			if (invalidImports.length > 0 && app.options.dev) {
+				app.logger.warn("[nitro-graphql] Some resolver imports could not be generated:");
+				for (const msg of invalidImports) app.logger.warn(`  - ${msg}`);
+			}
+			const data = imports.map(({ imports: importList }) => importList.map((i) => `{ resolver: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n");
+			return [
+				...importsContent,
+				"",
+				"export const resolvers = [",
+				data,
+				"]",
+				""
+			].join("\n");
+		} catch (error) {
+			app.logger.error("[nitro-graphql] Failed to generate virtual resolver module:", error);
+			return "export const resolvers = []";
+		}
+	};
+}
+function virtualDirectives(app) {
+	const getDirectives = () => app.scanDirectives || [];
+	app.options.virtual ??= {};
+	app.options.virtual["#nitro-graphql/server-directives"] = () => {
+		try {
+			const imports = getDirectives();
+			if (imports.length === 0) return "export const directives = []";
+			const importsContent = [];
+			const invalidImports = [];
+			for (const { specifier, imports: importList, options } of imports) try {
+				if (!importList || importList.length === 0) {
+					invalidImports.push(`${specifier}: No exports found`);
+					continue;
+				}
+				const importCode = genImport(specifier, importList, options);
+				importsContent.push(importCode);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				invalidImports.push(`${specifier}: ${message}`);
+				if (app.options.dev) app.logger.error(`[nitro-graphql] Failed to generate import for directive ${specifier}:`, error);
+			}
+			if (invalidImports.length > 0 && app.options.dev) {
+				app.logger.warn("[nitro-graphql] Some directive imports could not be generated:");
+				for (const msg of invalidImports) app.logger.warn(`  - ${msg}`);
+			}
+			const data = imports.map(({ imports: importList }) => importList.map((i) => `{ directive: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n");
+			return [
+				...importsContent,
+				"",
+				"export const directives = [",
+				data,
+				"]",
+				""
+			].join("\n");
+		} catch (error) {
+			app.logger.error("[nitro-graphql] Failed to generate virtual directive module:", error);
+			return "export const directives = []";
+		}
+	};
+}
+function getGraphQLConfig(app) {
+	const configPath = resolve(app.graphql.serverDir, "config.ts");
+	app.options.virtual ??= {};
+	app.options.virtual["#nitro-graphql/graphql-config"] = () => {
+		return `import config from '${configPath}'
+const importedConfig = config
+export { importedConfig }
+`;
+	};
+}
+function virtualModuleConfig(app) {
+	app.options.virtual ??= {};
+	app.options.virtual["#nitro-graphql/module-config"] = () => {
+		const moduleConfig = app.options.graphql || {};
+		return `export const moduleConfig = ${JSON.stringify(moduleConfig, null, 2)};`;
+	};
+}
+function virtualDebugInfo(app) {
+	app.options.virtual ??= {};
+	app.options.virtual["#nitro-graphql/debug-info"] = () => {
+		const virtualModuleCodes = {};
+		try {
+			const schemasGenerator = app.options.virtual["#nitro-graphql/server-schemas"];
+			if (schemasGenerator && typeof schemasGenerator === "function") virtualModuleCodes["server-schemas"] = schemasGenerator();
+		} catch (error) {
+			virtualModuleCodes["server-schemas"] = `// Error generating: ${error instanceof Error ? error.message : String(error)}`;
+		}
+		try {
+			const resolversGenerator = app.options.virtual["#nitro-graphql/server-resolvers"];
+			if (resolversGenerator && typeof resolversGenerator === "function") virtualModuleCodes["server-resolvers"] = resolversGenerator();
+		} catch (error) {
+			virtualModuleCodes["server-resolvers"] = `// Error generating: ${error instanceof Error ? error.message : String(error)}`;
+		}
+		try {
+			const directivesGenerator = app.options.virtual["#nitro-graphql/server-directives"];
+			if (directivesGenerator && typeof directivesGenerator === "function") virtualModuleCodes["server-directives"] = directivesGenerator();
+		} catch (error) {
+			virtualModuleCodes["server-directives"] = `// Error generating: ${error instanceof Error ? error.message : String(error)}`;
+		}
+		try {
+			const moduleConfigGenerator = app.options.virtual["#nitro-graphql/module-config"];
+			if (moduleConfigGenerator && typeof moduleConfigGenerator === "function") virtualModuleCodes["module-config"] = moduleConfigGenerator();
+		} catch (error) {
+			virtualModuleCodes["module-config"] = `// Error generating: ${error instanceof Error ? error.message : String(error)}`;
+		}
+		try {
+			const graphqlConfigGenerator = app.options.virtual["#nitro-graphql/graphql-config"];
+			if (graphqlConfigGenerator && typeof graphqlConfigGenerator === "function") virtualModuleCodes["graphql-config"] = graphqlConfigGenerator();
+		} catch (error) {
+			virtualModuleCodes["graphql-config"] = `// Error generating: ${error instanceof Error ? error.message : String(error)}`;
+		}
+		const debugInfo = {
+			isDev: app.options.dev,
+			framework: app.options.framework.name,
+			graphqlFramework: app.options.graphql?.framework,
+			federation: app.options.graphql?.federation,
+			scanned: {
+				schemas: app.scanSchemas?.length || 0,
+				schemaFiles: app.scanSchemas || [],
+				resolvers: app.scanResolvers?.length || 0,
+				resolverFiles: app.scanResolvers || [],
+				directives: app.scanDirectives?.length || 0,
+				directiveFiles: app.scanDirectives || [],
+				documents: app.scanDocuments?.length || 0,
+				documentFiles: app.scanDocuments || []
+			},
+			virtualModules: virtualModuleCodes
+		};
+		return `export const debugInfo = ${JSON.stringify(debugInfo, null, 2)};`;
+	};
+}
+
+//#endregion
+export { getGraphQLConfig, rollupConfig, virtualDebugInfo, virtualDirectives, virtualModuleConfig, virtualResolvers, virtualSchemas };

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

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

package/dist/routes/{apollo-server.js → apollo-server.mjs}

@@ -1,17 +1,17 @@
-import { consola as consola$1 } from "consola";
 import defu from "defu";
+import { consola as consola$1 } from "consola";
 import { parse } from "graphql";
 import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
-import { importedConfig } from "#nitro-internal-virtual/graphql-config";
-import { moduleConfig } from "#nitro-internal-virtual/module-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 { importedConfig } from "#nitro-graphql/graphql-config";
+import { moduleConfig } from "#nitro-graphql/module-config";
+import { directives } from "#nitro-graphql/server-directives";
+import { resolvers } from "#nitro-graphql/server-resolvers";
+import { schemas } from "#nitro-graphql/server-schemas";
 import { ApolloServer } from "@apollo/server";
 import { ApolloServerPluginLandingPageLocalDefault } from "@apollo/server/plugin/landingPage/default";
 import { makeExecutableSchema } from "@graphql-tools/schema";
-import { defineEventHandler } from "h3";
 import { startServerAndCreateH3Handler } from "nitro-graphql/utils/apollo";
+import { defineEventHandler } from "nitro/h3";
 
 //#region src/routes/apollo-server.ts
 let buildSubgraphSchema = null;

package/dist/routes/debug.d.mts

@@ -0,0 +1,61 @@
+import * as nitro_deps_h30 from "nitro/deps/h3";
+
+//#region src/routes/debug.d.ts
+
+/**
+ * Debug endpoint for inspecting virtual modules and GraphQL setup
+ * Only available in development mode
+ *
+ * Routes:
+ * - /_nitro/graphql/debug - HTML dashboard
+ * - /_nitro/graphql/debug?format=json - JSON API
+ */
+declare const _default: nitro_deps_h30.EventHandlerWithFetch<nitro_deps_h30.EventHandlerRequest, Promise<string | {
+  timestamp: string;
+  environment: {
+    dev: any;
+    framework: any;
+  };
+  graphql: {
+    framework: any;
+    federation: any;
+  };
+  scanned: {
+    schemas: any;
+    schemaFiles: any;
+    resolvers: any;
+    resolverFiles: any;
+    directives: any;
+    directiveFiles: any;
+    documents: any;
+    documentFiles: any;
+  };
+  runtime: {
+    loadedResolvers: number;
+    loadedSchemas: number;
+    loadedDirectives: number;
+  };
+  virtualModules: any;
+  virtualModuleSamples: {
+    'server-resolvers': {
+      resolverCount: number;
+      sample: {
+        hasResolver: boolean;
+        resolverKeys: string[];
+      }[];
+    };
+    'server-schemas': {
+      schemaCount: number;
+      sample: {
+        defLength: number;
+        defPreview: string;
+      }[];
+    };
+    'server-directives': {
+      directiveCount: number;
+    };
+    'module-config': Record<string, any>;
+  };
+}>>;
+//#endregion
+export { _default as default };