nitro-graphql 0.0.5 → 0.0.7

package/README.md

@@ -46,21 +46,6 @@ export default defineNitroConfig({
     endpoint: '/api/graphql', // default
     playground: true, // default (Apollo Sandbox)
     cors: false, // default
-    cacheHeaders: {
-      enabled: true, // default
-      maxAge: 604800, // default (1 week)
-    },
-    client: {
-      enabled: false, // default
-      outputPath: undefined, // Will default to .nitro/types/graphql-client.generated.ts
-      watchPatterns: undefined, // Will default to src/**/*.{graphql,gql} excluding server/graphql
-      config: {
-        documentMode: 'string',
-        emitLegacyCommonJSImports: false,
-        useTypeImports: true,
-        enumsAsTypes: true,
-      }
-    }
   }
 })
 ```
@@ -173,7 +158,7 @@ The module automatically generates TypeScript types from your GraphQL schema:
 These types are automatically available in your resolvers:
 
 ```ts
-import type { QueryResolvers } from '#build/graphql-types.generated'
+import type { QueryResolvers } from '#graphql/server'
 // server/graphql/users/user-queries.ts
 import { defineResolver } from 'nitro-graphql'
 
@@ -258,12 +243,6 @@ interface NitroGraphQLYogaOptions {
     methods?: string[]
   }
 
-  // Cache headers configuration
-  cacheHeaders?: {
-    enabled?: boolean // default: true
-    maxAge?: number // default: 604800 (1 week)
-  }
-
   // Client type generation
   client?: {
     enabled?: boolean // default: false
@@ -362,14 +341,6 @@ Enable client type generation for your frontend queries:
 // nitro.config.ts
 export default defineNitroConfig({
   graphqlYoga: {
-    client: {
-      enabled: true,
-      watchPatterns: [
-        'client/**/*.graphql',
-        'pages/**/*.vue',
-        'components/**/*.vue'
-      ]
-    }
   }
 })
 ```

package/dist/ecosystem/nuxt.d.ts

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

package/dist/ecosystem/nuxt.js

@@ -1,5 +1,5 @@
-import { join } from "pathe";
-import { addImportsDir, defineNuxtModule } from "@nuxt/kit";
+import { join, resolve } from "pathe";
+import { defineNuxtModule } from "@nuxt/kit";
 
 //#region src/ecosystem/nuxt.ts
 var nuxt_default = defineNuxtModule({
@@ -8,20 +8,21 @@ var nuxt_default = defineNuxtModule({
 		configKey: "nitro-graphql-nuxt",
 		compatibility: { nuxt: ">=3.16.0" }
 	},
-	defaults: {},
-	setup: (options, nuxt) => {
-		nuxt.hooks.hook("prepare:types", (options$1) => {
-			options$1.references.push({ path: "types/nitro-graphql-client.d.ts" });
-			options$1.tsConfig ??= {};
-			options$1.tsConfig.compilerOptions ??= {};
-			options$1.tsConfig.compilerOptions.paths ??= {};
-			options$1.tsConfig.compilerOptions.paths["#graphql/client"] = ["./types/nitro-graphql-client.d.ts"];
-			options$1.tsConfig.include = options$1.tsConfig.include || [];
-			options$1.tsConfig.include.push("./types/nitro-graphql-client.d.ts");
+	setup: async (_options, nuxt) => {
+		nuxt.hooks.hook("prepare:types", (options) => {
+			options.references.push({ path: "types/nitro-graphql-client.d.ts" });
+			options.tsConfig ??= {};
+			options.tsConfig.compilerOptions ??= {};
+			options.tsConfig.compilerOptions.paths ??= {};
+			options.tsConfig.compilerOptions.paths["#graphql/client"] = ["./types/nitro-graphql-client.d.ts"];
+			options.tsConfig.include = options.tsConfig.include || [];
+			options.tsConfig.include.push("./types/nitro-graphql-client.d.ts");
 		});
 		nuxt.options.alias = nuxt.options.alias || {};
 		nuxt.options.alias["#graphql/client"] = join(nuxt.options.buildDir, "types/nitro-graphql-client.d.ts");
-		addImportsDir(join(nuxt.options.srcDir, "graphql"));
+		nuxt.hook("imports:dirs", (dirs) => {
+			dirs.push(resolve(nuxt.options.srcDir, "graphql"));
+		});
 	}
 });
 

package/dist/graphql/index.d.ts

@@ -0,0 +1,5 @@
+//#region src/graphql/index.d.ts
+interface StandardSchemaV1 extends Record<string, any> {}
+interface ResolversTypes extends Record<string, any> {}
+//#endregion
+export { ResolversTypes, StandardSchemaV1 };

package/dist/graphql/server.d.ts

@@ -0,0 +1,5 @@
+//#region src/graphql/server.d.ts
+interface StandardSchemaV1 extends Record<string, any> {}
+interface ResolversTypes extends Record<string, any> {}
+//#endregion
+export { ResolversTypes, StandardSchemaV1 };

package/dist/index.d.ts

@@ -1,6 +1,12 @@
-import * as nitropack5 from "nitropack";
+import { StandardSchemaV1 } from "./types/standard-schema.js";
+import { CodegenClientConfig, CodegenServerConfig, GenImport, NitroGraphQLOptions } from "./types/index.js";
+import { defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType } from "./utils/define.js";
+import * as nitropack0 from "nitropack";
 
 //#region src/index.d.ts
-declare const _default: nitropack5.NitroModule;
+interface Resolvers extends Record<string, any> {}
+interface CustomSchema extends Record<string, any> {}
+type GraphQLFramework = 'graphql-yoga';
+declare const _default: nitropack0.NitroModule;
 //#endregion
-export { _default as default };
+export { CodegenClientConfig, CodegenServerConfig, CustomSchema, GenImport, GraphQLFramework, NitroGraphQLOptions, Resolvers, StandardSchemaV1, _default as default, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

package/dist/index.js

@@ -1,9 +1,11 @@
 import { relativeWithDot, scanDefs, scanResolvers } from "./utils/index.js";
 import { clientTypeGeneration, serverTypeGeneration } from "./utils/server-type-generation.js";
 import { rollupConfig } from "./rollup.js";
+import { defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType } from "./utils/define.js";
 import { writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { watch } from "chokidar";
+import defu from "defu";
 import { defineNitroModule } from "nitropack/kit";
 import { dirname, join, resolve } from "pathe";
 
@@ -14,8 +16,28 @@ var src_default = defineNitroModule({
 		nitro.graphql ||= {
 			buildDir: "",
 			watchDirs: [],
-			clientDir: ""
+			clientDir: "",
+			serverDir: resolve(nitro.options.srcDir, "graphql")
 		};
+		nitro.hooks.hook("rollup:before", (nitro$1, rollupConfig$1) => {
+			rollupConfig$1.external = rollupConfig$1.external || [];
+			const codegenExternals = ["oxc-parser", "@oxc-parser"];
+			if (Array.isArray(rollupConfig$1.external)) rollupConfig$1.external.push(...codegenExternals);
+			else if (typeof rollupConfig$1.external === "function") {
+				const originalExternal = rollupConfig$1.external;
+				rollupConfig$1.external = (id, parent, isResolved) => {
+					if (codegenExternals.some((external) => id.includes(external))) return true;
+					return originalExternal(id, parent, isResolved);
+				};
+			}
+		});
+		nitro.options.runtimeConfig.graphql = defu(nitro.options.runtimeConfig.graphql || {}, {
+			endpoint: {
+				graphql: "/api/graphql",
+				healthCheck: "/api/graphql/health"
+			},
+			playground: true
+		});
 		const graphqlBuildDir = resolve(nitro.options.buildDir, "graphql");
 		nitro.graphql.buildDir = graphqlBuildDir;
 		const watchDirs = [];
@@ -26,13 +48,16 @@ var src_default = defineNitroModule({
 				break;
 			default:
 		}
-		watch(watchDirs, {
+		const watcher = watch(watchDirs, {
 			persistent: true,
 			ignoreInitial: true,
 			ignored: nitro.options.ignore
 		}).on("all", async (event, path) => {
 			if (path.endsWith(".graphql") || path.endsWith(".gql")) await clientTypeGeneration(nitro, path);
 		});
+		nitro.hooks.hook("close", () => {
+			watcher.close();
+		});
 		const tsConfigPath = resolve(nitro.options.buildDir, nitro.options.typescript.tsconfigPath);
 		const tsconfigDir = dirname(tsConfigPath);
 		const typesDir = resolve(nitro.options.buildDir, "types");
@@ -49,26 +74,38 @@ var src_default = defineNitroModule({
 		await rollupConfig(nitro);
 		await serverTypeGeneration(nitro);
 		await clientTypeGeneration(nitro, nitro.graphql.clientDir);
-		const endpoint = "/api/graphql";
 		const runtime = fileURLToPath(new URL("routes", import.meta.url));
-		nitro.options.handlers.push({
-			route: endpoint,
-			handler: join(runtime, "graphql"),
-			method: "get"
+		const methods = [
+			"get",
+			"post",
+			"options"
+		];
+		if (nitro.options.graphql?.framework === "graphql-yoga") for (const method of methods) nitro.options.handlers.push({
+			route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
+			handler: join(runtime, "graphql-yoga"),
+			method
 		});
-		nitro.options.handlers.push({
-			route: endpoint,
-			handler: join(runtime, "graphql"),
-			method: "post"
+		if (nitro.options.graphql?.framework === "apollo-server") for (const method of methods) nitro.options.handlers.push({
+			route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
+			handler: join(runtime, "apollo-server"),
+			method
 		});
 		nitro.options.handlers.push({
-			route: endpoint,
-			handler: join(runtime, "graphql"),
-			method: "options"
+			route: nitro.options.runtimeConfig.graphql?.endpoint?.healthCheck || "/api/graphql/health",
+			handler: join(runtime, "health"),
+			method: "get"
 		});
 		if (nitro.options.imports) nitro.options.imports.presets.push({
-			from: "nitro-graphql/utils",
-			imports: ["defineResolver", "defineYogaConfig"]
+			from: "nitro-graphql/utils/define",
+			imports: [
+				"defineResolver",
+				"defineMutation",
+				"defineQuery",
+				"defineSubscription",
+				"defineType",
+				"defineGraphQLConfig",
+				"defineSchema"
+			]
 		});
 		nitro.hooks.hook("rollup:before", (nitro$1, rollupConfig$1) => {
 			const manualChunks = rollupConfig$1.output?.manualChunks;
@@ -86,19 +123,26 @@ var src_default = defineNitroModule({
 			};
 		});
 		const graphqlDtsContent = `// Auto-generated by nitro-graphql
-import type { Resolvers as Test } from './nitro-graphql-server.d.ts'
 
-declare module 'nitro-graphql/types' {
+import type { Resolvers as Test, SchemaType } from './nitro-graphql-server.d.ts'
+
+declare module 'nitro-graphql' {
   interface Resolvers extends Test {}
+
+  interface CustomSchema extends SchemaType {}
+
+  type GraphQLFramework = '${nitro.options.graphql?.framework || "graphql-yoga"}'
 }
 `;
 		writeFileSync(join(typesDir, "graphql.d.ts"), graphqlDtsContent);
+		nitro.options.typescript.strict = true;
 		nitro.hooks.hook("types:extend", (types) => {
 			types.tsConfig ||= {};
 			types.tsConfig.compilerOptions ??= {};
 			types.tsConfig.compilerOptions.paths ??= {};
 			types.tsConfig.compilerOptions.paths["#graphql/server"] = [relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-server.d.ts"))];
 			types.tsConfig.compilerOptions.paths["#graphql/client"] = [relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-client.d.ts"))];
+			types.tsConfig.compilerOptions.paths["#graphql/schemas"] = [relativeWithDot(tsconfigDir, join(nitro.graphql.serverDir, "schemas.ts"))];
 			types.tsConfig.include = types.tsConfig.include || [];
 			types.tsConfig.include.push(relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-server.d.ts")), relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-client.d.ts")), relativeWithDot(tsconfigDir, join(typesDir, "graphql.d.ts")));
 		});
@@ -106,4 +150,4 @@ declare module 'nitro-graphql/types' {
 });
 
 //#endregion
-export { src_default as default };
+export { src_default as default, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

package/dist/node_modules/.pnpm/@graphql-codegen_plugin-helpers@3.1.2_graphql@16.11.0/node_modules/@graphql-codegen/plugin-helpers/esm/federation.js

@@ -2,8 +2,8 @@ import { __toESM } from "../../../../../../../_virtual/rolldown_runtime.js";
 import "./utils.js";
 import { require_merge } from "../../../../../lodash@4.17.21/node_modules/lodash/merge.js";
 import "./index.js";
-import "@graphql-tools/utils";
 import { isObjectType, parse } from "graphql";
+import "@graphql-tools/utils";
 
 //#region node_modules/.pnpm/@graphql-codegen+plugin-helpers@3.1.2_graphql@16.11.0/node_modules/@graphql-codegen/plugin-helpers/esm/federation.js
 var import_merge = __toESM(require_merge(), 1);

package/dist/rollup.js

@@ -1,8 +1,8 @@
-import { scanGraphql } from "./utils/index.js";
+import { getImportId, scanGraphql } from "./utils/index.js";
 import { serverTypeGeneration } from "./utils/server-type-generation.js";
-import { parse } from "graphql";
 import { readFile } from "node:fs/promises";
-import { hash } from "ohash";
+import { parse } from "graphql";
+import { genImport } from "knitwork";
 
 //#region src/rollup.ts
 async function rollupConfig(app) {
@@ -41,9 +41,6 @@ async function rollupConfig(app) {
 		await serverTypeGeneration(app);
 	});
 }
-function getImportId(p, lazy) {
-	return (lazy ? "_lazy_" : "_") + hash(p).replace(/-/g, "").slice(0, 6);
-}
 function virtualDefs(app) {
 	const getDefs = () => {
 		const defs = [...app.scanDefs, ...app.options.graphql?.typedefs ?? []];
@@ -64,18 +61,24 @@ ${imports.map((h) => `{ def: ${getImportId(h)} }`).join(",\n")}
 }
 function virtualResolvers(app) {
 	const getResolvers = () => {
-		const resolvers = [...app.scanResolvers, ...app.options.graphql?.resolvers ?? []];
+		const resolvers = [...app.scanResolvers];
 		return resolvers;
 	};
 	app.options.virtual ??= {};
 	app.options.virtual["#nitro-internal-virtual/server-resolvers"] = () => {
 		const imports = getResolvers();
-		const code = `
-${imports.map((handler) => `import ${getImportId(handler)} from '${handler}';`).join("\n")}  
-export const resolvers = [
-${imports.map((h) => `{ resolver: ${getImportId(h)} }`).join(",\n")}
-];
-    `;
+		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) => `{ resolver: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n");
+		const content = [
+			"export const resolvers = [",
+			data,
+			"]",
+			""
+		];
+		content.unshift(...importsContent);
+		const code = content.join("\n");
 		return code;
 	};
 }

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

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

package/dist/routes/apollo-server.js

@@ -0,0 +1,39 @@
+import { startServerAndCreateH3Handler } from "../utils/apollo.js";
+import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
+import { defs } from "#nitro-internal-virtual/server-defs";
+import { resolvers } from "#nitro-internal-virtual/server-resolvers";
+import { ApolloServer } from "@apollo/server";
+import { ApolloServerPluginLandingPageLocalDefault } from "@apollo/server/plugin/landingPage/default";
+
+//#region src/routes/apollo-server.ts
+function createMergedSchema() {
+	try {
+		const mergedDefs = defs.map((schema) => schema.def).join("\n\n");
+		const typeDefs = mergeTypeDefs([mergedDefs]);
+		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
+		return {
+			typeDefs,
+			resolvers: mergedResolvers
+		};
+	} catch (error) {
+		console.error("Schema merge error:", error);
+		throw error;
+	}
+}
+let apolloServer;
+function createApolloServer() {
+	if (!apolloServer) {
+		const { typeDefs, resolvers: mergedResolvers } = createMergedSchema();
+		apolloServer = new ApolloServer({
+			typeDefs,
+			resolvers: mergedResolvers,
+			introspection: true,
+			plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })]
+		});
+	}
+	return apolloServer;
+}
+var apollo_server_default = startServerAndCreateH3Handler(createApolloServer, { context: async (event) => ({ event }) });
+
+//#endregion
+export { apollo_server_default as default };

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

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

package/dist/routes/{graphql.js → graphql-yoga.js}

@@ -1,10 +1,10 @@
-import { createSchema, createYoga } from "graphql-yoga";
 import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
 import { defs } from "#nitro-internal-virtual/server-defs";
 import { resolvers } from "#nitro-internal-virtual/server-resolvers";
-import { defineEventHandler } from "h3";
+import { defineEventHandler, toWebRequest } from "h3";
+import { createSchema, createYoga } from "graphql-yoga";
 
-//#region src/routes/graphql.ts
+//#region src/routes/graphql-yoga.ts
 const apolloSandboxHtml = `<!DOCTYPE html>
 <html lang="en">
 <body style="margin: 0; overflow-x: hidden; overflow-y: hidden">
@@ -37,7 +37,7 @@ function createMergedSchema() {
 	}
 }
 let yoga;
-var graphql_default = defineEventHandler(async (event) => {
+var graphql_yoga_default = defineEventHandler(async (event) => {
 	if (!yoga) {
 		const schema = createMergedSchema();
 		yoga = createYoga({
@@ -47,8 +47,10 @@ var graphql_default = defineEventHandler(async (event) => {
 			renderGraphiQL: () => apolloSandboxHtml
 		});
 	}
-	return yoga.handle(event.node.req, event.node.res);
+	const request = toWebRequest(event);
+	const response = await yoga.handleRequest(request, event);
+	return new Response(response.body, response);
 });
 
 //#endregion
-export { graphql_default as default };
+export { graphql_yoga_default as default };

package/dist/routes/health.d.ts

@@ -0,0 +1,10 @@
+import * as h36 from "h3";
+
+//#region src/routes/health.d.ts
+declare const _default: h36.EventHandler<h36.EventHandlerRequest, Promise<{
+  status: string;
+  message: string;
+  timestamp: string;
+}>>;
+//#endregion
+export { _default as default };

package/dist/routes/health.js

@@ -0,0 +1,44 @@
+import { defineEventHandler, setResponseStatus } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+
+//#region src/routes/health.ts
+var health_default = defineEventHandler(async (event) => {
+	const runtime = useRuntimeConfig();
+	if (!runtime.graphql || !runtime.graphql.endpoint?.graphql) {
+		setResponseStatus(event, 404);
+		return {
+			status: "error",
+			message: "GraphQL health check endpoint is not configured",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+	try {
+		const response = await $fetch(runtime.graphql.endpoint?.graphql, {
+			method: "POST",
+			body: {
+				query: "query Health { __typename }",
+				operationName: "Health"
+			},
+			headers: {
+				"Content-Type": "application/json",
+				"Accept": "application/json"
+			}
+		});
+		if (response && typeof response === "object" && "data" in response) return {
+			status: "healthy",
+			message: "GraphQL server is running",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		throw new Error("Invalid response from GraphQL server");
+	} catch (error) {
+		setResponseStatus(event, 503);
+		return {
+			status: "unhealthy",
+			message: error instanceof Error ? error.message : "GraphQL server is not responding",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+});
+
+//#endregion
+export { health_default as default };

package/dist/{types.d.ts → types/index.d.ts}

@@ -1,20 +1,31 @@
-import { TypeScriptPluginConfig } from "@graphql-codegen/typescript";
-import { TypeScriptResolversPluginConfig } from "@graphql-codegen/typescript-resolvers";
+import { StandardSchemaV1 } from "./standard-schema.js";
+import { ESMCodeGenOptions } from "knitwork";
 import { IResolvers } from "@graphql-tools/utils";
+import { TypeScriptPluginConfig } from "@graphql-codegen/typescript";
 import { TypeScriptDocumentsPluginConfig } from "@graphql-codegen/typescript-operations";
-import { YogaServerOptions } from "graphql-yoga";
-import { IncomingMessage, ServerResponse } from "node:http";
+import { TypeScriptResolversPluginConfig } from "@graphql-codegen/typescript-resolvers";
 
-//#region src/types.d.ts
+//#region src/types/index.d.ts
 type CodegenServerConfig = TypeScriptPluginConfig & TypeScriptResolversPluginConfig;
+interface IESMImport {
+  name: string;
+  as?: string;
+  type: 'resolver' | 'query' | 'mutation' | 'type' | 'subscription';
+}
+interface GenImport {
+  specifier: string;
+  imports: IESMImport[];
+  options?: ESMCodeGenOptions;
+}
 declare module 'nitropack/types' {
   interface Nitro {
     scanDefs: string[];
-    scanResolvers: any;
+    scanResolvers: GenImport[];
     graphql: {
       buildDir: string;
       watchDirs: string[];
       clientDir: string;
+      serverDir: string;
     };
   }
 }
@@ -29,22 +40,17 @@ declare module 'nitropack' {
     graphql?: NitroGraphQLOptions;
   }
 }
-interface GraphQLSchemaConfig {
-  typeDefs: string | string[];
-  resolvers: any;
-}
 interface CodegenClientConfig extends TypeScriptPluginConfig, TypeScriptDocumentsPluginConfig {
   endpoint?: string;
   documentMode?: 'string' | 'graphQLTag' | 'documentNode' | 'documentNodeImportFragments' | 'external';
 }
 interface NitroGraphQLOptions {
-  endpoint?: string;
-  healthCheckEndpoint?: string;
+  framework: 'graphql-yoga' | 'apollo-server';
+  endpoint?: {
+    graphql?: string;
+    healthCheck?: string;
+  };
   playground?: boolean;
-  cors?: YogaServerOptions<{
-    req: IncomingMessage;
-    res: ServerResponse;
-  }, any>['cors'];
   typedefs?: string[];
   resolvers?: Array<IResolvers<any, any>>;
   loader?: {
@@ -52,22 +58,10 @@ interface NitroGraphQLOptions {
     exclude?: RegExp;
     validate?: boolean;
   };
-  cacheHeaders?: {
-    enabled?: boolean;
-    maxAge?: number;
-  };
   codegen?: {
     server?: CodegenServerConfig;
     client?: CodegenClientConfig;
   };
-  client?: {
-    enabled?: boolean;
-    outputPath?: string;
-    watchPatterns?: string[];
-    nuxtPatterns?: string[];
-  };
-  yogaConfig?: Partial<YogaServerOptions<any, any>>;
 }
-interface Resolvers {}
 //#endregion
-export { CodegenClientConfig, CodegenServerConfig, GraphQLSchemaConfig, NitroGraphQLOptions, Resolvers };
+export { CodegenClientConfig, CodegenServerConfig, GenImport, NitroGraphQLOptions };

package/dist/types/standard-schema.d.ts

@@ -0,0 +1,59 @@
+//#region src/types/standard-schema.d.ts
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  export interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  export type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  export interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  export interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  export interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  export interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  export interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+  /** Infers the output type of a Standard Schema. */
+  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+  export {};
+}
+//#endregion
+export { StandardSchemaV1 };

package/dist/utils/apollo.js

@@ -0,0 +1,62 @@
+import { HeaderMap } from "@apollo/server";
+import { eventHandler, getHeaders, isMethod, readBody, setHeaders } from "h3";
+
+//#region src/utils/apollo.ts
+function startServerAndCreateH3Handler(server, options) {
+	const apolloServer = typeof server === "function" ? server() : server;
+	apolloServer.startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests();
+	const defaultContext = () => Promise.resolve({});
+	const contextFunction = options?.context ?? defaultContext;
+	return eventHandler({
+		handler: async (event) => {
+			if (isMethod(event, "OPTIONS")) return null;
+			try {
+				const graphqlRequest = await toGraphqlRequest(event);
+				const { body, headers, status } = await apolloServer.executeHTTPGraphQLRequest({
+					httpGraphQLRequest: graphqlRequest,
+					context: () => contextFunction({ event })
+				});
+				if (body.kind === "chunked") throw new Error("Incremental delivery not implemented");
+				setHeaders(event, Object.fromEntries(headers));
+				event.res.statusCode = status || 200;
+				return body.string;
+			} catch (error) {
+				if (error instanceof SyntaxError) {
+					event.res.statusCode = 400;
+					return error.message;
+				} else throw error;
+			}
+		},
+		websocket: options?.websocket
+	});
+}
+async function toGraphqlRequest(event) {
+	return {
+		method: event.req.method || "POST",
+		headers: normalizeHeaders(getHeaders(event)),
+		search: normalizeQueryString(event.req.url),
+		body: await normalizeBody(event)
+	};
+}
+function normalizeHeaders(headers) {
+	const headerMap = new HeaderMap();
+	for (const [key, value] of Object.entries(headers)) if (Array.isArray(value)) headerMap.set(key, value.join(","));
+	else if (value) headerMap.set(key, value);
+	return headerMap;
+}
+function normalizeQueryString(url) {
+	if (!url) return "";
+	return url.split("?")[1] || "";
+}
+async function normalizeBody(event) {
+	const PayloadMethods = [
+		"PATCH",
+		"POST",
+		"PUT",
+		"DELETE"
+	];
+	if (isMethod(event, PayloadMethods)) return await readBody(event);
+}
+
+//#endregion
+export { startServerAndCreateH3Handler };

package/dist/{client-codegen.js → utils/client-codegen.js}

@@ -1,16 +1,16 @@
-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 { codegen } from "@graphql-codegen/core";
-import { plugin } from "@graphql-codegen/typescript";
+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 { defu as defu$1 } from "defu";
+import { parse } from "graphql";
 import { printSchemaWithDirectives } from "@graphql-tools/utils";
 import { consola as consola$1 } from "consola";
-import { defu } from "defu";
-import { parse } from "graphql";
-import { plugin as plugin$1 } from "@graphql-codegen/typescript-operations";
-import { plugin as plugin$2 } from "@graphql-codegen/typescript-generic-sdk";
+import { codegen } from "@graphql-codegen/core";
+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";
 import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
 import { loadDocuments } from "@graphql-tools/load";
 
-//#region src/client-codegen.ts
+//#region src/utils/client-codegen.ts
 function pluginContent(_schema, _documents, _config, _info) {
 	return {
 		prepend: [
@@ -54,7 +54,7 @@ async function generateClientTypes(schema, docs, config = {}, outputPath) {
 			Currency: "string"
 		}
 	};
-	const mergedConfig = defu(config, defaultConfig);
+	const mergedConfig = defu$1(config, defaultConfig);
 	try {
 		const output = await codegen({
 			filename: outputPath || "client-types.generated.ts",
@@ -69,7 +69,7 @@ async function generateClientTypes(schema, docs, config = {}, outputPath) {
 			pluginMap: {
 				pluginContent: { plugin: pluginContent },
 				typescript: { plugin },
-				typescriptOperations: { plugin: plugin$1 }
+				typescriptOperations: { plugin: plugin$2 }
 			}
 		});
 		const sdkOutput = await preset.buildGeneratesSection({
@@ -86,7 +86,8 @@ async function generateClientTypes(schema, docs, config = {}, outputPath) {
 					UUID: "string",
 					NonEmptyString: "string",
 					Currency: "string"
-				}
+				},
+				useTypeImports: true
 			},
 			presetConfig: { typesPath: "#graphql/client" },
 			plugins: [
@@ -96,8 +97,8 @@ async function generateClientTypes(schema, docs, config = {}, outputPath) {
 			],
 			pluginMap: {
 				pluginContent: { plugin: pluginContent },
-				typescriptOperations: { plugin: plugin$1 },
-				typescriptGenericSdk: { plugin: plugin$2 }
+				typescriptOperations: { plugin: plugin$2 },
+				typescriptGenericSdk: { plugin: plugin$1 }
 			}
 		});
 		const results = await Promise.all(sdkOutput.map(async (config$1) => {

package/dist/utils/define.d.ts

@@ -0,0 +1,17 @@
+import { ApolloServerOptions, BaseContext } from "@apollo/server";
+import { YogaServerOptions } from "graphql-yoga";
+import { ResolversTypes, StandardSchemaV1 } from "#graphql/server";
+import { GraphQLFramework, Resolvers } from "nitro-graphql";
+
+//#region src/utils/define.d.ts
+type Flatten<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;
+declare function defineSchema<T extends Partial<Record<keyof ResolversTypes, StandardSchemaV1>>>(config: T): Flatten<T>;
+declare function defineResolver(resolvers: Resolvers): Resolvers;
+declare function defineQuery(resolvers?: Resolvers['Query']): Resolvers;
+declare function defineMutation(resolvers?: Resolvers['Mutation']): Resolvers;
+declare function defineSubscription(resolvers?: Resolvers['Subscription']): Resolvers;
+declare function defineType(resolvers: Resolvers): Resolvers;
+type DefineServerConfig = GraphQLFramework extends 'graphql-yoga' ? Partial<YogaServerOptions<any, any>> : GraphQLFramework extends 'apollo-server' ? Partial<ApolloServerOptions<BaseContext>> : Record<string, any>;
+declare function defineGraphQLConfig(config: Partial<DefineServerConfig>): Partial<DefineServerConfig>;
+//#endregion
+export { defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

package/dist/utils/define.js

@@ -0,0 +1,25 @@
+//#region src/utils/define.ts
+function defineSchema(config) {
+	return config;
+}
+function defineResolver(resolvers) {
+	return resolvers;
+}
+function defineQuery(resolvers = {}) {
+	return { Query: { ...resolvers } };
+}
+function defineMutation(resolvers = {}) {
+	return { Mutation: { ...resolvers } };
+}
+function defineSubscription(resolvers = {}) {
+	return { Subscription: { ...resolvers } };
+}
+function defineType(resolvers) {
+	return resolvers;
+}
+function defineGraphQLConfig(config) {
+	return config;
+}
+
+//#endregion
+export { defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

package/dist/utils/index.d.ts

@@ -1,21 +1,15 @@
+import { GenImport } from "../types/index.js";
 import { Nitro } from "nitropack";
-import { YogaServerOptions } from "graphql-yoga";
-import { GraphQLSchemaConfig, Resolvers } from "nitro-graphql/types";
 
 //#region src/utils/index.d.ts
 declare const GLOB_SCAN_PATTERN = "**/*.{graphql,gql,js,mjs,cjs,ts,mts,cts,tsx,jsx}";
-declare function defineGraphQLSchema(config: GraphQLSchemaConfig): GraphQLSchemaConfig;
-declare function defineResolver(resolvers: Resolvers): Resolvers;
-/**
- * Helper function to define GraphQL Yoga configuration with type safety
- */
-declare function defineYogaConfig<TServerContext = any, TUserContext = any>(config: Partial<YogaServerOptions<TServerContext, TUserContext>>): Partial<YogaServerOptions<TServerContext, TUserContext>>;
+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<string[]>;
+declare function scanResolvers(nitro: Nitro): Promise<GenImport[]>;
 declare function scanDirectives(nitro: Nitro): Promise<string[]>;
 declare function scanTypeDefs(nitro: Nitro): Promise<string[]>;
 declare function scanDefs(nitro: Nitro): Promise<string[]>;
 declare function unique(arr: any[]): any[];
 //#endregion
-export { GLOB_SCAN_PATTERN, defineGraphQLSchema, defineResolver, defineYogaConfig, relativeWithDot, scanDefs, scanDirectives, scanGraphql, scanResolvers, scanTypeDefs, unique };
+export { GLOB_SCAN_PATTERN, getImportId, relativeWithDot, scanDefs, scanDirectives, scanGraphql, scanResolvers, scanTypeDefs, unique };

package/dist/utils/index.js

@@ -1,19 +1,13 @@
 import { join, relative } from "pathe";
+import { readFile } from "node:fs/promises";
+import { hash } from "ohash";
+import { parseAsync } from "oxc-parser";
 import { glob } from "tinyglobby";
 
 //#region src/utils/index.ts
 const GLOB_SCAN_PATTERN = "**/*.{graphql,gql,js,mjs,cjs,ts,mts,cts,tsx,jsx}";
-function defineGraphQLSchema(config) {
-	return config;
-}
-function defineResolver(resolvers) {
-	return resolvers;
-}
-/**
-* Helper function to define GraphQL Yoga configuration with type safety
-*/
-function defineYogaConfig(config) {
-	return config;
+function getImportId(p, lazy) {
+	return (lazy ? "_lazy_" : "_") + hash(p).replace(/-/g, "").slice(0, 6);
 }
 const RELATIVE_RE = /^\.{1,2}\//;
 function relativeWithDot(from, to) {
@@ -26,7 +20,48 @@ async function scanGraphql(nitro) {
 }
 async function scanResolvers(nitro) {
 	const files = await scanFiles(nitro, "graphql", "**/*.resolver.{ts,js}");
-	return files.map((f) => f.fullPath);
+	const exportName = [];
+	for (const file of files) {
+		const fileContent = await readFile(file.fullPath, "utf-8");
+		const parsed = await parseAsync(file.fullPath, fileContent);
+		const exports = {
+			imports: [],
+			specifier: file.fullPath
+		};
+		for (const node of parsed.program.body) if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "VariableDeclaration") {
+			for (const decl of node.declaration.declarations) if (decl.type === "VariableDeclarator" && decl.init && decl.id.type === "Identifier") {
+				if (decl.init && decl.init.type === "CallExpression") {
+					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineResolver") exports.imports.push({
+						name: decl.id.name,
+						type: "resolver",
+						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+					});
+					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineQuery") exports.imports.push({
+						name: decl.id.name,
+						type: "query",
+						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+					});
+					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineMutation") exports.imports.push({
+						name: decl.id.name,
+						type: "mutation",
+						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+					});
+					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineType") exports.imports.push({
+						name: decl.id.name,
+						type: "type",
+						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+					});
+					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineSubscription") exports.imports.push({
+						name: decl.id.name,
+						type: "subscription",
+						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+					});
+				}
+			}
+		}
+		if (exports.imports.length > 0) exportName.push(exports);
+	}
+	return exportName;
 }
 async function scanDirectives(nitro) {
 	const files = await scanFiles(nitro, "graphql", "**/*.directive.{ts,js}");
@@ -69,4 +104,4 @@ function unique(arr) {
 }
 
 //#endregion
-export { GLOB_SCAN_PATTERN, defineGraphQLSchema, defineResolver, defineYogaConfig, relativeWithDot, scanDefs, scanDirectives, scanGraphql, scanResolvers, scanTypeDefs, unique };
+export { GLOB_SCAN_PATTERN, getImportId, relativeWithDot, scanDefs, scanDirectives, scanGraphql, scanResolvers, scanTypeDefs, unique };

package/dist/{codegen.js → utils/server-codegen.js}

@@ -1,13 +1,13 @@
+import { defu as defu$1 } from "defu";
+import { parse } from "graphql";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import consola from "consola";
 import { codegen } from "@graphql-codegen/core";
 import * as typescriptPlugin from "@graphql-codegen/typescript";
 import * as typescriptResolversPlugin from "@graphql-codegen/typescript-resolvers";
-import { printSchemaWithDirectives } from "@graphql-tools/utils";
-import consola from "consola";
-import { defu } from "defu";
-import { parse } from "graphql";
 import { CurrencyResolver, DateTimeResolver, JSONResolver, NonEmptyStringResolver, UUIDResolver } from "graphql-scalars";
 
-//#region src/codegen.ts
+//#region src/utils/server-codegen.ts
 function pluginContent(_schema, _documents, _config, _info) {
 	return {
 		prepend: [
@@ -45,15 +45,12 @@ async function generateTypes(schema, config = {}, outputPath) {
 		},
 		defaultScalarType: "unknown",
 		defaultMapper: `ResolverReturnType<{T}>`,
-		contextType: "./context#GraphQLContext",
+		contextType: "h3#H3Event",
 		maybeValue: "T | null | undefined",
 		inputMaybeValue: "T | undefined",
-		enumsAsTypes: true,
-		useTypeImports: true,
-		strictScalars: true,
-		emitLegacyCommonJSImports: false
+		declarationKind: "interface"
 	};
-	const mergedConfig = defu(config, defaultConfig);
+	const mergedConfig = defu$1(config, defaultConfig);
 	const output = await codegen({
 		filename: outputPath || "types.generated.ts",
 		schema: parse(printSchemaWithDirectives(schema)),
@@ -67,35 +64,57 @@ async function generateTypes(schema, config = {}, outputPath) {
 		],
 		pluginMap: {
 			pluginContent: { plugin: pluginContent },
-			imports: { plugin: () => ({
-				prepend: [`type Primitive =
-    | null
-    | undefined
-    | string
-    | number
-    | boolean
-    | symbol
-    | bigint;
+			imports: { plugin: () => {
+				return {
+					prepend: [
+						`import schemas from '#graphql/schemas'`,
+						`import type { StandardSchemaV1 } from 'nitro-graphql'`,
+						`
+export type SchemaType = Partial<Record<Partial<keyof ResolversTypes>, StandardSchemaV1>>
+type SchemaKeys = keyof typeof schemas;
+
+type InferInput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferInput<T> : unknown;
+type InferOutput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<T> : unknown;
+
+type InferInputFromSchema<T extends SchemaKeys> = InferInput<(typeof schemas)[T]>;
+type InferOutputFromSchema<T extends SchemaKeys> = InferOutput<(typeof schemas)[T]>;
+
+type Primitive =
+| null
+| undefined
+| string
+| number
+| boolean
+| symbol
+| bigint;
 
 type BuiltIns = Primitive | void | Date | RegExp;
 
+
 type ResolverReturnType<T> = T extends BuiltIns
-    ? T
-    : T extends (...args: any[]) => unknown
-    ? T | undefined
-    : T extends object
-    ? T extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-        ? ItemType[] extends T // Test for arrays (non-tuples) specifically
-            ? Array<ResolverReturnType<ItemType>>
-            : ResolverReturnTypeObject<T> // Tuples behave properly
-        : ResolverReturnTypeObject<T>
-    : unknown;
+? T
+: T extends (...args: any[]) => unknown
+? T | undefined
+: T extends object
+? T extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+  ? ItemType[] extends T // Test for arrays (non-tuples) specifically
+    ? Array<ResolverReturnType<ItemType>>
+    : ResolverReturnTypeObject<T> // Tuples behave properly
+  : ResolverReturnTypeObject<T>
+: unknown;
 
-type ResolverReturnTypeObject<T extends object> = {
-  [K in keyof T]: ResolverReturnType<T[K]>
-};`, ""],
-				content: ""
-			}) },
+type ResolverReturnTypeObject<T extends object> =
+  T extends { __typename?: infer TTypename }
+    ? TTypename extends SchemaKeys
+      ? InferOutputFromSchema<TTypename>
+      : { [K in keyof T]: ResolverReturnType<T[K]> }
+    : { [K in keyof T]: ResolverReturnType<T[K]> };
+`,
+						""
+					],
+					content: ""
+				};
+			} },
 			typescript: typescriptPlugin,
 			typescriptResolvers: typescriptResolversPlugin
 		}

package/dist/utils/server-type-generation.js

@@ -1,12 +1,12 @@
-import { generateTypes } from "../codegen.js";
-import { generateClientTypes, loadGraphQLDocuments } from "../client-codegen.js";
-import { printSchemaWithDirectives } from "@graphql-tools/utils";
-import consola from "consola";
-import { buildASTSchema, buildSchema } from "graphql";
+import { generateClientTypes, loadGraphQLDocuments } from "./client-codegen.js";
+import { generateTypes } from "./server-codegen.js";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "pathe";
+import { buildASTSchema, buildSchema } from "graphql";
 import { loadFilesSync } from "@graphql-tools/load-files";
 import { mergeTypeDefs } from "@graphql-tools/merge";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import consola from "consola";
 
 //#region src/utils/server-type-generation.ts
 async function serverTypeGeneration(app) {

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "nitro-graphql",
   "type": "module",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "GraphQL integration for Nitro",
   "license": "MIT",
   "sideEffects": false,
+  "imports": {
+    "#graphql/server": {
+      "types": "./dist/graphql/server.d.ts",
+      "import": "./dist/graphql/server.js"
+    }
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -30,9 +36,9 @@
       "types": "./dist/utils/index.d.ts",
       "import": "./dist/utils/index.js"
     },
-    "./types": {
-      "types": "./dist/types.d.ts",
-      "import": "./dist/types.js"
+    "./utils/define": {
+      "types": "./dist/utils/define.d.ts",
+      "import": "./dist/utils/define.js"
     },
     "./internal": {
       "types": "./dist/internal/index.d.ts",
@@ -54,6 +60,8 @@
     "nitropack": "^2.11.13"
   },
   "dependencies": {
+    "@apollo/utils.withrequired": "^3.0.0",
+    "@as-integrations/h3": "^2.0.0",
     "@graphql-codegen/core": "^4.0.2",
     "@graphql-codegen/typescript": "^4.1.6",
     "@graphql-codegen/typescript-generic-sdk": "^4.0.2",
@@ -69,21 +77,25 @@
     "consola": "^3.4.2",
     "defu": "^6.1.4",
     "graphql-scalars": "^1.24.2",
-    "graphql-yoga": "^5.15.1",
+    "knitwork": "^1.2.0",
     "ohash": "^2.0.11",
+    "oxc-parser": "^0.77.0",
     "pathe": "^2.0.3",
     "tinyglobby": "^0.2.14"
   },
   "devDependencies": {
     "@antfu/eslint-config": "^4.16.2",
+    "@apollo/server": "^4.12.2",
     "@graphql-codegen/import-types-preset": "^3.0.1",
     "@nuxt/kit": "4.0.0-rc.0",
     "@nuxt/schema": "4.0.0-rc.0",
     "@types/node": "^20.19.7",
     "bumpp": "^10.2.0",
     "changelogen": "^0.6.2",
+    "crossws": "0.3.5",
     "eslint": "^9.31.0",
     "graphql": "^16.11.0",
+    "graphql-yoga": "^5.15.1",
     "h3": "^1.15.3",
     "nitropack": "^2.11.13",
     "tsdown": "^0.12.9",

package/dist/codegen.d.ts

@@ -1,7 +0,0 @@
-import { CodegenServerConfig } from "./types.js";
-import { GraphQLSchema } from "graphql";
-
-//#region src/codegen.d.ts
-declare function generateTypes(schema: GraphQLSchema, config?: CodegenServerConfig, outputPath?: string): Promise<string>;
-//#endregion
-export { generateTypes };

package/dist/context.d.ts

@@ -1,10 +0,0 @@
-import { YogaInitialContext } from "graphql-yoga";
-import { H3Event } from "h3";
-
-//#region src/context.d.ts
-interface GraphQLContext extends YogaInitialContext {
-  event: H3Event;
-  storage: any;
-}
-//#endregion
-export { GraphQLContext };

package/dist/graphql.d.ts

@@ -1,13 +0,0 @@
-import { NitroGraphQLOptions } from "./types.js";
-import { NitroConfig } from "nitropack";
-
-//#region src/graphql.d.ts
-declare module 'nitropack' {
-  interface NitroRuntimeHooks {}
-  interface NitroRuntimeConfig {}
-}
-declare module 'nitropack/config' {
-  function defineNitroConfig(config: NitroConfig & {
-    graphql?: NitroGraphQLOptions;
-  }): NitroConfig;
-}

package/dist/internal/create-merged-schema.d.ts

@@ -1,7 +0,0 @@
-import * as graphql8 from "graphql";
-import * as graphql_yoga9 from "graphql-yoga";
-
-//#region src/internal/create-merged-schema.d.ts
-declare function createMergedSchema(): graphql_yoga9.GraphQLSchemaWithContext<graphql8.GraphQLResolveInfo & graphql_yoga9.YogaInitialContext>;
-//#endregion
-export { createMergedSchema };

package/dist/internal/create-merged-schema.js

@@ -1,23 +0,0 @@
-import { createSchema } from "graphql-yoga";
-import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
-import { defs } from "#nitro-internal-virtual/server-defs";
-import { resolvers } from "#nitro-internal-virtual/server-resolvers";
-
-//#region src/internal/create-merged-schema.ts
-function createMergedSchema() {
-	try {
-		const mergedDefs = defs.map((schema) => schema.def).join("\n\n");
-		const typeDefs = mergeTypeDefs([mergedDefs]);
-		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
-		return createSchema({
-			typeDefs,
-			resolvers: mergedResolvers
-		});
-	} catch (error) {
-		console.error("Schema merge error:", error);
-		throw error;
-	}
-}
-
-//#endregion
-export { createMergedSchema };

package/dist/internal/index.d.ts

@@ -1,2 +0,0 @@
-import { createMergedSchema } from "./create-merged-schema.js";
-export { createMergedSchema };

package/dist/internal/index.js

@@ -1,3 +0,0 @@
-import { createMergedSchema } from "./create-merged-schema.js";
-
-export { createMergedSchema };

package/dist/routes/graphql.d.ts

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