nitro-graphql 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/ecosystem/nuxt.js

@@ -1,67 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join, 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) => {
-			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"];
-			const externalServices$1 = nuxt.options.nitro?.graphql?.externalServices || [];
-			for (const service of externalServices$1) {
-				options.references.push({ path: `types/nitro-graphql-client-${service.name}.d.ts` });
-				options.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [`./types/nitro-graphql-client-${service.name}.d.ts`];
-			}
-			options.tsConfig.include = options.tsConfig.include || [];
-			options.tsConfig.include.push("./types/nitro-graphql-client.d.ts");
-			for (const service of externalServices$1) options.tsConfig.include.push(`./types/nitro-graphql-client-${service.name}.d.ts`);
-		});
-		nuxt.options.alias = nuxt.options.alias || {};
-		nuxt.options.alias["#graphql/client"] = join(nuxt.options.buildDir, "types/nitro-graphql-client.d.ts");
-		const externalServices = nuxt.options.nitro?.graphql?.externalServices || [];
-		for (const service of externalServices) nuxt.options.alias[`#graphql/client/${service.name}`] = join(nuxt.options.buildDir, `types/nitro-graphql-client-${service.name}.d.ts`);
-		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/graphql/index.d.ts

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

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,264 +0,0 @@
-import { generateDirectiveSchemas } from "./utils/directive-parser.js";
-import { generateLayerIgnorePatterns, getLayerAppDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanResolvers, scanSchemas, validateExternalServices } from "./utils/index.js";
-import { clientTypeGeneration, serverTypeGeneration } from "./utils/type-generation.js";
-import { rollupConfig } from "./rollup.js";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { watch } from "chokidar";
-import consola from "consola";
-import defu from "defu";
-import { dirname, join, relative, resolve } from "pathe";
-
-//#region src/index.ts
-var src_default = defineNitroModule({
-	name: "nitro-graphql",
-	async setup(nitro) {
-		if (!nitro.options.graphql?.framework) consola.warn("No GraphQL framework specified. Please set graphql.framework to \"graphql-yoga\" or \"apollo-server\".");
-		if (nitro.options.graphql?.externalServices?.length) {
-			const validationErrors = validateExternalServices(nitro.options.graphql.externalServices);
-			if (validationErrors.length > 0) {
-				consola.error("External services configuration errors:");
-				for (const error of validationErrors) consola.error(`  - ${error}`);
-				throw new Error("Invalid external services configuration");
-			}
-			consola.info(`Configured ${nitro.options.graphql.externalServices.length} external GraphQL services`);
-		}
-		nitro.graphql ||= {
-			buildDir: "",
-			watchDirs: [],
-			clientDir: "",
-			serverDir: resolve(nitro.options.rootDir, "server", "graphql"),
-			dir: {
-				build: relative(nitro.options.rootDir, nitro.options.buildDir),
-				client: "graphql",
-				server: "server"
-			}
-		};
-		nitro.hooks.hook("rollup:before", (_, 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
-		});
-		if (nitro.options.graphql?.federation?.enabled) consola.info(`Apollo Federation enabled for service: ${nitro.options.graphql.federation.serviceName || "unnamed"}`);
-		const graphqlBuildDir = resolve(nitro.options.buildDir, "graphql");
-		nitro.graphql.buildDir = graphqlBuildDir;
-		const watchDirs = [];
-		switch (nitro.options.framework.name) {
-			case "nuxt": {
-				if (!nitro.graphql.clientDir) {
-					nitro.graphql.clientDir = resolve(nitro.options.rootDir, "app", "graphql");
-					nitro.graphql.dir.client = "app/graphql";
-				}
-				if (!nitro.options.graphql?.serverDir) nitro.graphql.serverDir = resolve(nitro.options.rootDir, "server", "graphql");
-				watchDirs.push(nitro.graphql.clientDir);
-				const layerServerDirs = getLayerServerDirectories(nitro);
-				const layerAppDirs = getLayerAppDirectories(nitro);
-				for (const layerServerDir of layerServerDirs) watchDirs.push(join(layerServerDir, "graphql"));
-				for (const layerAppDir of layerAppDirs) watchDirs.push(join(layerAppDir, "graphql"));
-				break;
-			}
-			case "nitro":
-				if (!nitro.options.graphql?.serverDir) nitro.graphql.serverDir = resolve(nitro.options.rootDir, "server", "graphql");
-				nitro.graphql.clientDir = resolve(nitro.options.rootDir, "graphql");
-				nitro.graphql.dir.client = "graphql";
-				watchDirs.push(nitro.graphql.clientDir);
-				watchDirs.push(nitro.graphql.serverDir);
-				break;
-			default:
-		}
-		if (nitro.options.graphql?.externalServices?.length) {
-			for (const service of nitro.options.graphql.externalServices) if (service.documents?.length) for (const pattern of service.documents) {
-				if (!pattern) continue;
-				const baseDir = pattern.split("**")[0]?.replace(/\/$/, "") || ".";
-				const resolvedDir = resolve(nitro.options.rootDir, baseDir);
-				if (!watchDirs.includes(resolvedDir)) watchDirs.push(resolvedDir);
-			}
-		}
-		const watcher = watch(watchDirs, {
-			persistent: true,
-			ignoreInitial: true,
-			ignored: [...nitro.options.ignore, ...generateLayerIgnorePatterns(nitro)]
-		}).on("all", async (_, path) => {
-			if (path.endsWith(".graphql") || path.endsWith(".gql")) if (path.includes(nitro.graphql.serverDir) || path.includes("server/graphql") || path.includes("server\\graphql")) {
-				await serverTypeGeneration(nitro);
-				await clientTypeGeneration(nitro);
-				await nitro.hooks.callHook("dev:reload");
-			} else await clientTypeGeneration(nitro);
-		});
-		nitro.hooks.hook("close", () => {
-			watcher.close();
-		});
-		const tsconfigDir = dirname(resolve(nitro.options.buildDir, nitro.options.typescript.tsconfigPath));
-		const typesDir = resolve(nitro.options.buildDir, "types");
-		nitro.scanSchemas = await scanSchemas(nitro);
-		nitro.scanDocuments = await scanDocs(nitro);
-		nitro.scanResolvers = await scanResolvers(nitro);
-		const directives = await scanDirectives(nitro);
-		nitro.scanDirectives = directives;
-		await generateDirectiveSchemas(nitro, directives);
-		nitro.hooks.hook("dev:start", async () => {
-			nitro.scanSchemas = await scanSchemas(nitro);
-			nitro.scanResolvers = await scanResolvers(nitro);
-			const directives$1 = await scanDirectives(nitro);
-			nitro.scanDirectives = directives$1;
-			await generateDirectiveSchemas(nitro, directives$1);
-			nitro.scanDocuments = await scanDocs(nitro);
-		});
-		await rollupConfig(nitro);
-		await serverTypeGeneration(nitro);
-		await clientTypeGeneration(nitro);
-		nitro.hooks.hook("close", async () => {
-			await serverTypeGeneration(nitro);
-			await clientTypeGeneration(nitro);
-		});
-		const runtime = fileURLToPath(new URL("routes", import.meta.url));
-		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
-		});
-		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: nitro.options.runtimeConfig.graphql?.endpoint?.healthCheck || "/api/graphql/health",
-			handler: join(runtime, "health"),
-			method: "GET"
-		});
-		if (nitro.options.imports) {
-			nitro.options.imports.presets ??= [];
-			nitro.options.imports.presets.push({
-				from: fileURLToPath(new URL("utils/define", import.meta.url)),
-				imports: [
-					"defineResolver",
-					"defineMutation",
-					"defineQuery",
-					"defineSubscription",
-					"defineType",
-					"defineGraphQLConfig",
-					"defineSchema",
-					"defineDirective"
-				]
-			});
-		}
-		nitro.hooks.hook("rollup:before", (_, rollupConfig$1) => {
-			const manualChunks = rollupConfig$1.output?.manualChunks;
-			const chunkFiles = rollupConfig$1.output?.chunkFileNames;
-			if (!rollupConfig$1.output.inlineDynamicImports) rollupConfig$1.output.manualChunks = (id, meta) => {
-				if (id.endsWith(".graphql") || id.endsWith(".gql")) return "schemas";
-				if (id.endsWith(".resolver.ts")) return "resolvers";
-				if (typeof manualChunks === "function") return manualChunks(id, meta);
-			};
-			rollupConfig$1.output.chunkFileNames = (chunkInfo) => {
-				if (chunkInfo.moduleIds && chunkInfo.moduleIds.some((id) => id.endsWith(".graphql") || id.endsWith(".resolver.ts") || id.endsWith(".gql"))) return `chunks/graphql/[name].mjs`;
-				if (typeof chunkFiles === "function") return chunkFiles(chunkInfo);
-				return `chunks/_/[name].mjs`;
-			};
-		});
-		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/schema"] = [relativeWithDot(tsconfigDir, join(nitro.graphql.serverDir, "schema.ts"))];
-			if (nitro.options.graphql?.externalServices?.length) for (const service of nitro.options.graphql.externalServices) types.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [relativeWithDot(tsconfigDir, join(typesDir, `nitro-graphql-client-${service.name}.d.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")));
-			if (nitro.options.graphql?.externalServices?.length) for (const service of nitro.options.graphql.externalServices) types.tsConfig.include.push(relativeWithDot(tsconfigDir, join(typesDir, `nitro-graphql-client-${service.name}.d.ts`)));
-		});
-		if (nitro.options.framework?.name === "nuxt" && nitro.options.graphql?.externalServices?.length) nitro.hooks.hook("build:before", () => {
-			const nuxtOptions = nitro._nuxt?.options;
-			if (nuxtOptions) nuxtOptions.nitroGraphqlExternalServices = nitro.options.graphql?.externalServices || [];
-		});
-		if (!existsSync(join(nitro.options.rootDir, "graphql.config.ts"))) {
-			const schemaPath = relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.buildDir, "schema.graphql"));
-			const documentsPath = relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.clientDir, "**/*.{graphql,js,ts,jsx,tsx}"));
-			writeFileSync(join(nitro.options.rootDir, "graphql.config.ts"), `
-import type { IGraphQLConfig } from 'graphql-config'
-
-export default <IGraphQLConfig> {
-    projects: {
-      default: {
-        schema: [
-          '${schemaPath}',
-        ],
-        documents: [
-          '${documentsPath}',
-        ],
-      },
-    },
-}`, "utf-8");
-		}
-		if (!existsSync(nitro.graphql.serverDir)) mkdirSync(nitro.graphql.serverDir, { recursive: true });
-		if (!existsSync(join(nitro.graphql.serverDir, "schema.ts"))) writeFileSync(join(nitro.graphql.serverDir, "schema.ts"), `
-import { defineSchema } from 'nitro-graphql/utils/define'      
-      
-export default defineSchema({
-
-})
-`, "utf-8");
-		if (!existsSync(join(nitro.graphql.serverDir, "config.ts"))) writeFileSync(join(nitro.graphql.serverDir, "config.ts"), `// Example GraphQL config file please change it to your needs
-// import * as tables from '../drizzle/schema/index'
-// import { useDatabase } from '../utils/useDb'
-import { defineGraphQLConfig } from 'nitro-graphql/utils/define'
-
-export default defineGraphQLConfig({
-// graphql-yoga example config
-// context: () => {
-//   return {
-//     context: {
-//       useDatabase,
-//       tables,
-//     },
-//   }
-// },
-})
-`, "utf-8");
-		if (!existsSync(join(nitro.graphql.serverDir, "context.ts"))) writeFileSync(join(nitro.graphql.serverDir, "context.ts"), `// Example context definition - please change it to your needs
-// import type { Database } from '../utils/useDb'
-
-declare module 'h3' {
-  interface H3EventContext {
-    // Add your custom context properties here
-    // useDatabase: () => Database
-    // tables: typeof import('../drizzle/schema')
-    // auth?: {
-    //   user?: {
-    //     id: string
-    //     role: 'admin' | 'user'
-    //   }
-    // }
-  }
-}`, "utf-8");
-		if (existsSync(join(nitro.graphql.serverDir, "context.d.ts"))) {
-			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");
-		}
-	}
-});
-
-//#endregion
-export { src_default as default };

package/dist/rollup.js

@@ -1,119 +0,0 @@
-import { getImportId, scanGraphql } from "./utils/index.js";
-import { clientTypeGeneration, serverTypeGeneration } from "./utils/type-generation.js";
-import { resolve } from "pathe";
-import { readFile } from "node:fs/promises";
-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);
-	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",
-				enforce: "pre",
-				resolveId(id) {
-					if (/\.(graphql|gql)$/i.test(id)) return null;
-				},
-				async load(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}`);
-					}
-				}
-			});
-			rollupConfig$1.plugins.push({
-				name: "nitro-graphql-watcher",
-				enforce: "pre",
-				async buildStart() {
-					const graphqlFiles = await scanGraphql(nitro);
-					for (const file of graphqlFiles) this.addWatchFile(file);
-				}
-			});
-		}
-	});
-	app.hooks.hook("dev:reload", async () => {
-		await serverTypeGeneration(app);
-		await clientTypeGeneration(app);
-	});
-}
-function virtualSchemas(app) {
-	const getSchemas = () => [...app.scanSchemas, ...app.options.graphql?.typedefs ?? []];
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-internal-virtual/server-schemas"] = () => {
-		const imports = getSchemas();
-		return `
-${imports.map((handler) => `import ${getImportId(handler)} from '${handler}';`).join("\n")}
-
-export const schemas = [
-${imports.map((h) => `{ def: ${getImportId(h)} }`).join(",\n")}
-];
-    `;
-	};
-}
-function virtualResolvers(app) {
-	const getResolvers = () => [...app.scanResolvers];
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-internal-virtual/server-resolvers"] = () => {
-		const imports = getResolvers();
-		const importsContent = imports.map(({ specifier, imports: imports$1, options }) => 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");
-		return [
-			...importsContent,
-			"export const resolvers = [",
-			data,
-			"]",
-			""
-		].join("\n");
-	};
-}
-function virtualDirectives(app) {
-	const getDirectives = () => app.scanDirectives || [];
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-internal-virtual/server-directives"] = () => {
-		const imports = getDirectives();
-		const importsContent = imports.map(({ specifier, imports: imports$1, options }) => 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");
-		return [
-			...importsContent,
-			"export const directives = [",
-			data,
-			"]",
-			""
-		].join("\n");
-	};
-}
-function getGraphQLConfig(app) {
-	const configPath = resolve(app.graphql.serverDir, "config.ts");
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-internal-virtual/graphql-config"] = () => {
-		return `import config from '${configPath}'
-const importedConfig = config
-export { importedConfig }
-`;
-	};
-}
-function virtualModuleConfig(app) {
-	app.options.virtual ??= {};
-	app.options.virtual["#nitro-internal-virtual/module-config"] = () => {
-		const moduleConfig = app.options.graphql || {};
-		return `export const moduleConfig = ${JSON.stringify(moduleConfig, null, 2)};`;
-	};
-}
-
-//#endregion
-export { rollupConfig };

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

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

package/dist/routes/apollo-server.js

@@ -1,89 +0,0 @@
-import { consola as consola$1 } from "consola";
-import defu from "defu";
-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 { 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";
-
-//#region src/routes/apollo-server.ts
-let buildSubgraphSchema = null;
-async function loadFederationSupport() {
-	if (buildSubgraphSchema !== null) return buildSubgraphSchema;
-	try {
-		buildSubgraphSchema = (await import("@apollo/subgraph")).buildSubgraphSchema;
-	} catch {
-		buildSubgraphSchema = false;
-	}
-	return buildSubgraphSchema;
-}
-async function createMergedSchema() {
-	try {
-		const typeDefs = mergeTypeDefs([schemas.map((schema$1) => schema$1.def).join("\n\n")], {
-			throwOnConflict: true,
-			commentDescriptions: true,
-			sort: true
-		});
-		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
-		const federationEnabled = moduleConfig.federation?.enabled;
-		let schema;
-		if (federationEnabled) {
-			const buildSubgraph = await loadFederationSupport();
-			if (buildSubgraph) schema = buildSubgraph({
-				typeDefs: typeof typeDefs === "string" ? parse(typeDefs) : typeDefs,
-				resolvers: mergedResolvers
-			});
-			else {
-				console.warn("Federation enabled but @apollo/subgraph not available, falling back to regular schema");
-				schema = makeExecutableSchema({
-					typeDefs,
-					resolvers: mergedResolvers
-				});
-			}
-		} else schema = makeExecutableSchema({
-			typeDefs,
-			resolvers: mergedResolvers
-		});
-		if (directives && directives.length > 0) {
-			for (const { directive } of directives) if (directive.transformer) schema = directive.transformer(schema);
-		}
-		return schema;
-	} catch (error) {
-		consola$1.error("Schema merge error:", error);
-		throw error;
-	}
-}
-let apolloServer = null;
-let serverStarted = false;
-async function createApolloServer() {
-	if (!apolloServer) {
-		apolloServer = new ApolloServer(defu({
-			schema: await createMergedSchema(),
-			introspection: true,
-			plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })]
-		}, importedConfig));
-		if (!serverStarted) {
-			await apolloServer.start();
-			serverStarted = true;
-		}
-	}
-	return apolloServer;
-}
-let serverPromise = null;
-var apollo_server_default = defineEventHandler(async (event) => {
-	if (!serverPromise) serverPromise = createApolloServer();
-	return startServerAndCreateH3Handler(await serverPromise, {
-		context: async () => ({ event }),
-		serverAlreadyStarted: true
-	})(event);
-});
-
-//#endregion
-export { apollo_server_default as default };

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

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

package/dist/routes/graphql-yoga.js

@@ -1,91 +0,0 @@
-import { consola as consola$1 } from "consola";
-import defu from "defu";
-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 { makeExecutableSchema } from "@graphql-tools/schema";
-import { defineEventHandler } from "h3";
-import { createYoga } from "graphql-yoga";
-
-//#region src/routes/graphql-yoga.ts
-let buildSubgraphSchema = null;
-async function loadFederationSupport() {
-	if (buildSubgraphSchema !== null) return buildSubgraphSchema;
-	try {
-		buildSubgraphSchema = (await import("@apollo/subgraph")).buildSubgraphSchema;
-	} catch {
-		buildSubgraphSchema = false;
-	}
-	return buildSubgraphSchema;
-}
-const apolloSandboxHtml = `<!DOCTYPE html>
-<html lang="en">
-<body style="margin: 0; overflow-x: hidden; overflow-y: hidden">
-<div id="sandbox" style="height:100vh; width:100vw;"></div>
-<script src="https://embeddable-sandbox.cdn.apollographql.com/02e2da0fccbe0240ef03d2396d6c98559bab5b06/embeddable-sandbox.umd.production.min.js"><\/script>
-<script>
-new window.EmbeddedSandbox({
-  target: "#sandbox",
-  initialEndpoint: window.location.href,
-  hideCookieToggle: false,
-  initialState: {
-    includeCookies: true
-  }
-});
-<\/script>
-</body>
-</html>`;
-async function createMergedSchema() {
-	try {
-		const typeDefs = mergeTypeDefs([schemas.map((schema$1) => schema$1.def).join("\n\n")], {
-			throwOnConflict: true,
-			commentDescriptions: true,
-			sort: true
-		});
-		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
-		const federationEnabled = moduleConfig.federation?.enabled;
-		let schema;
-		if (federationEnabled) {
-			const buildSubgraph = await loadFederationSupport();
-			if (buildSubgraph) schema = buildSubgraph({
-				typeDefs: typeof typeDefs === "string" ? parse(typeDefs) : typeDefs,
-				resolvers: mergedResolvers
-			});
-			else {
-				console.warn("Federation enabled but @apollo/subgraph not available, falling back to regular schema");
-				schema = makeExecutableSchema({
-					typeDefs,
-					resolvers: mergedResolvers
-				});
-			}
-		} else schema = makeExecutableSchema({
-			typeDefs,
-			resolvers: mergedResolvers
-		});
-		if (directives && directives.length > 0) {
-			for (const { directive } of directives) if (directive.transformer) schema = directive.transformer(schema);
-		}
-		return schema;
-	} catch (error) {
-		consola$1.error("Schema merge error:", error);
-		throw error;
-	}
-}
-let yoga;
-var graphql_yoga_default = defineEventHandler(async (event) => {
-	if (!yoga) yoga = createYoga(defu({
-		schema: await createMergedSchema(),
-		graphqlEndpoint: "/api/graphql",
-		landingPage: false,
-		renderGraphiQL: () => apolloSandboxHtml
-	}, importedConfig));
-	const response = await yoga.handleRequest(event.req, event);
-	return new Response(response.body, response);
-});
-
-//#endregion
-export { graphql_yoga_default as default };

package/dist/routes/health.d.ts

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