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

package/dist/nitro/setup/rollup-integration.mjs

@@ -0,0 +1,90 @@
+import { CHUNK_NAME_RESOLVERS, CHUNK_NAME_SCHEMAS, CHUNK_PATH_GRAPHQL, CHUNK_PATH_UNKNOWN, GRAPHQL_EXTENSIONS, RESOLVER_EXTENSIONS } from "../../core/constants.mjs";
+
+//#region src/nitro/setup/rollup-integration.ts
+/**
+* Setup Rollup/Rolldown chunking configuration for GraphQL files
+* Creates separate chunks for schemas and resolvers to optimize bundle size
+*/
+function setupRollupChunking(nitro) {
+	nitro.hooks.hook("rollup:before", (_, rollupConfig) => {
+		const manualChunks = rollupConfig.output?.manualChunks;
+		const chunkFiles = rollupConfig.output?.chunkFileNames;
+		if (!rollupConfig.output.inlineDynamicImports) {
+			rollupConfig.output.manualChunks = (id, _meta) => {
+				if (isGraphQLFile(id)) return getSchemaChunkName(id);
+				if (isResolverFile(id)) return getResolverChunkName(id);
+				if (typeof manualChunks === "function") return manualChunks(id, meta);
+			};
+			rollupConfig.output.advancedChunks = {
+				groups: [{
+					name: CHUNK_NAME_SCHEMAS,
+					test: /* @__PURE__ */ new RegExp(`\\.(${GRAPHQL_EXTENSIONS.map((e) => e.slice(1)).join("|")})$`)
+				}, {
+					name: CHUNK_NAME_RESOLVERS,
+					test: /\.resolver\.(ts|js)$/
+				}],
+				minSize: 0,
+				minShareCount: 1
+			};
+		}
+		rollupConfig.output.chunkFileNames = (chunkInfo) => {
+			if (chunkInfo.moduleIds && chunkInfo.moduleIds.some((id) => isGraphQLFile(id) || isResolverFile(id))) return CHUNK_PATH_GRAPHQL;
+			if (typeof chunkFiles === "function") return chunkFiles(chunkInfo);
+			return CHUNK_PATH_UNKNOWN;
+		};
+	});
+}
+/**
+* Check if a file is a GraphQL schema file
+*/
+function isGraphQLFile(id) {
+	return GRAPHQL_EXTENSIONS.some((ext) => id.endsWith(ext));
+}
+/**
+* Check if a file is a resolver file
+*/
+function isResolverFile(id) {
+	return RESOLVER_EXTENSIONS.some((ext) => id.endsWith(ext));
+}
+/**
+* Get chunk name for GraphQL schema files
+* All schemas are bundled into a single chunk since GraphQL server
+* merges them at runtime anyway - no benefit from separate chunks
+*/
+function getSchemaChunkName(_id) {
+	return CHUNK_NAME_SCHEMAS;
+}
+/**
+* Get chunk name for resolver files
+* All resolvers are bundled into a single chunk since GraphQL server
+* requires all resolvers to be registered at startup - no runtime lazy loading
+*/
+function getResolverChunkName(_id) {
+	return CHUNK_NAME_RESOLVERS;
+}
+/**
+* Configure external dependencies for Rollup
+* Marks codegen and federation packages as external
+*/
+function setupRollupExternals(nitro) {
+	nitro.hooks.hook("rollup:before", (_, rollupConfig) => {
+		rollupConfig.external = rollupConfig.external || [];
+		const allExternals = [...["oxc-parser", "@oxc-parser"]];
+		if (!nitro.options.graphql?.federation?.enabled) allExternals.push(...[
+			"@apollo/subgraph",
+			"@apollo/federation-internals",
+			"@apollo/cache-control-types"
+		]);
+		if (Array.isArray(rollupConfig.external)) rollupConfig.external.push(...allExternals);
+		else if (typeof rollupConfig.external === "function") {
+			const originalExternal = rollupConfig.external;
+			rollupConfig.external = (id, parent, isResolved) => {
+				if (allExternals.some((external) => id.includes(external))) return true;
+				return originalExternal(id, parent, isResolved);
+			};
+		}
+	});
+}
+
+//#endregion
+export { setupRollupChunking, setupRollupExternals };

package/dist/nitro/setup/routes.d.mts

@@ -0,0 +1,10 @@
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/setup/routes.d.ts
+
+/**
+ * Register GraphQL route handlers
+ */
+declare function registerRouteHandlers(nitro: Nitro): void;
+//#endregion
+export { registerRouteHandlers };

package/dist/nitro/setup/routes.mjs

@@ -0,0 +1,35 @@
+import { ENDPOINT_DEBUG, GRAPHQL_HTTP_METHODS } from "../../core/constants.mjs";
+import { join } from "pathe";
+import { fileURLToPath } from "node:url";
+
+//#region src/nitro/setup/routes.ts
+/**
+* Register GraphQL route handlers
+*/
+function registerRouteHandlers(nitro) {
+	const runtime = fileURLToPath(new URL("../routes", import.meta.url));
+	const framework = nitro.options.graphql?.framework;
+	if (framework === "graphql-yoga") for (const method of GRAPHQL_HTTP_METHODS) nitro.options.handlers.push({
+		route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
+		handler: join(runtime, "graphql-yoga"),
+		method
+	});
+	if (framework === "apollo-server") for (const method of GRAPHQL_HTTP_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.dev) nitro.options.handlers.push({
+		route: ENDPOINT_DEBUG,
+		handler: join(runtime, "debug"),
+		method: "GET"
+	});
+}
+
+//#endregion
+export { registerRouteHandlers };

package/dist/nitro/setup/ts-config.d.mts

@@ -0,0 +1,11 @@
+import { Nitro, NitroTypes } from "nitro/types";
+
+//#region src/nitro/setup/ts-config.d.ts
+
+/**
+ * Setup TypeScript path aliases for GraphQL types
+ * Called via nitro:config hook to extend tsconfig.json
+ */
+declare function setupTypeScriptPaths(nitro: Nitro, types: NitroTypes): void;
+//#endregion
+export { setupTypeScriptPaths };

package/dist/nitro/setup/ts-config.mjs

@@ -0,0 +1,69 @@
+import { relativeWithDot } from "../../core/utils/imports.mjs";
+import { getDefaultPaths, getTypesConfig, resolveFilePath } from "../paths.mjs";
+import { dirname, join, resolve } from "pathe";
+
+//#region src/nitro/setup/ts-config.ts
+/**
+* Setup TypeScript path aliases for GraphQL types
+* Called via nitro:config hook to extend tsconfig.json
+*/
+function setupTypeScriptPaths(nitro, types) {
+	const tsconfigDir = dirname(resolve(nitro.options.buildDir, nitro.options.typescript.tsconfigPath));
+	types.tsConfig ||= {};
+	types.tsConfig.compilerOptions ??= {};
+	types.tsConfig.compilerOptions.paths ??= {};
+	types.tsConfig.include = types.tsConfig.include || [];
+	const placeholders = getDefaultPaths(nitro);
+	const typesConfig = getTypesConfig(nitro);
+	setupServerTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig);
+	setupClientTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig);
+	setupSchemaPath(nitro, types, tsconfigDir);
+	setupExternalServicePaths(nitro, types, tsconfigDir, placeholders, typesConfig);
+	types.tsConfig.include.push(relativeWithDot(tsconfigDir, join(placeholders.typesDir, "graphql.d.ts")));
+}
+/**
+* Setup #graphql/server path alias
+*/
+function setupServerTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig) {
+	const serverTypesPath = resolveFilePath(typesConfig.server, typesConfig.enabled, true, "{typesDir}/nitro-graphql-server.d.ts", placeholders);
+	if (serverTypesPath) {
+		types.tsConfig.compilerOptions.paths["#graphql/server"] = [relativeWithDot(tsconfigDir, serverTypesPath)];
+		types.tsConfig.include.push(relativeWithDot(tsconfigDir, serverTypesPath));
+	}
+}
+/**
+* Setup #graphql/client path alias
+*/
+function setupClientTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig) {
+	const clientTypesPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
+	if (clientTypesPath) {
+		types.tsConfig.compilerOptions.paths["#graphql/client"] = [relativeWithDot(tsconfigDir, clientTypesPath)];
+		types.tsConfig.include.push(relativeWithDot(tsconfigDir, clientTypesPath));
+	}
+}
+/**
+* Setup #graphql/schema path alias
+*/
+function setupSchemaPath(nitro, types, tsconfigDir) {
+	types.tsConfig.compilerOptions.paths["#graphql/schema"] = [relativeWithDot(tsconfigDir, join(nitro.graphql.serverDir, "schema.ts"))];
+}
+/**
+* Setup #graphql/client/{serviceName} path aliases for external services
+*/
+function setupExternalServicePaths(nitro, types, tsconfigDir, placeholders, typesConfig) {
+	if (!nitro.options.graphql?.externalServices?.length) return;
+	for (const service of nitro.options.graphql.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) {
+			types.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [relativeWithDot(tsconfigDir, externalTypesPath)];
+			types.tsConfig.include.push(relativeWithDot(tsconfigDir, externalTypesPath));
+		}
+	}
+}
+
+//#endregion
+export { setupTypeScriptPaths };

package/dist/nitro/setup.d.mts

@@ -0,0 +1,12 @@
+import { resolveSecurityConfig } from "./setup/logging.mjs";
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/setup.d.ts
+
+/**
+ * Main setup function for nitro-graphql
+ * Coordinates all initialization steps for the module
+ */
+declare function setupNitroGraphQL(nitro: Nitro): Promise<void>;
+//#endregion
+export { resolveSecurityConfig, setupNitroGraphQL };

package/dist/nitro/setup.mjs

@@ -0,0 +1,234 @@
+import { FRAMEWORK_NITRO, FRAMEWORK_NUXT, LOG_TAG } from "../core/constants.mjs";
+import { generateDirectiveSchemas } from "../core/utils/directive-parser.mjs";
+import { validateExternalServices } from "../core/validation/external-services.mjs";
+import { NitroAdapter } from "./adapter.mjs";
+import { getDefaultPaths } from "./paths.mjs";
+import { generateClientTypes, generateServerTypes } from "./codegen.mjs";
+import { DEFAULT_RUNTIME_CONFIG, DEFAULT_TYPESCRIPT_STRICT, DEFAULT_TYPES_CONFIG } from "./config.mjs";
+import { rollupConfig } from "./rollup.mjs";
+import { resolveExtendConfig, resolveExtendDirs } from "./setup/extend-loader.mjs";
+import { getWatchDirectories, setupFileWatcher } from "./setup/file-watcher.mjs";
+import { logStartupInfo, resolveSecurityConfig } from "./setup/logging.mjs";
+import { setupRollupChunking, setupRollupExternals } from "./setup/rollup-integration.mjs";
+import { registerRouteHandlers } from "./setup/routes.mjs";
+import { setupTypeScriptPaths } from "./setup/ts-config.mjs";
+import defu from "defu";
+import consola from "consola";
+import { relative, resolve } from "pathe";
+
+//#region src/nitro/setup.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Scan all GraphQL files and update Nitro state
+*/
+async function scanAllGraphQLFiles(nitro) {
+	const directivesResult = await NitroAdapter.scanDirectives(nitro);
+	nitro.scanDirectives = directivesResult.items;
+	if (!nitro.scanSchemas) nitro.scanSchemas = [];
+	const directivesPath = await generateDirectiveSchemas(nitro, directivesResult.items);
+	const schemas = (await NitroAdapter.scanSchemas(nitro)).items;
+	if (directivesPath && !schemas.includes(directivesPath)) schemas.push(directivesPath);
+	nitro.scanSchemas = schemas;
+	nitro.scanDocuments = (await NitroAdapter.scanDocuments(nitro)).items;
+	nitro.scanResolvers = (await NitroAdapter.scanResolvers(nitro)).items;
+}
+/**
+* Main setup function for nitro-graphql
+* Coordinates all initialization steps for the module
+*/
+async function setupNitroGraphQL(nitro) {
+	const serverEnabled = nitro.options.graphql?.server !== false;
+	initializeConfiguration(nitro, serverEnabled);
+	validateConfiguration(nitro);
+	setupBuildDirectories(nitro);
+	if (serverEnabled) {
+		setupRollupExternals(nitro);
+		setupRollupChunking(nitro);
+	}
+	initializeRuntimeConfig(nitro);
+	setupFileWatching(nitro, serverEnabled, await resolveExtendDirs(nitro));
+	await scanGraphQLFiles(nitro, serverEnabled);
+	await resolveExtendConfig(nitro);
+	if (serverEnabled) setupDevHooks(nitro);
+	if (serverEnabled) await rollupConfig(nitro);
+	await generateTypes(nitro, serverEnabled);
+	setupCloseHooks(nitro, serverEnabled);
+	if (serverEnabled) registerRouteHandlers(nitro);
+	setupTypeScriptConfiguration(nitro);
+	setupNuxtIntegration(nitro);
+	logStartupInfo(nitro, serverEnabled);
+}
+/**
+* Initialize default configuration values
+*/
+function initializeConfiguration(nitro, serverEnabled) {
+	nitro.options.graphql ||= {};
+	nitro.options.graphql.types = defu(nitro.options.graphql.types, DEFAULT_TYPES_CONFIG);
+	if (serverEnabled && !nitro.options.graphql?.framework) logger.warn("No GraphQL framework specified. Please set graphql.framework to \"graphql-yoga\" or \"apollo-server\".");
+	const defaultPaths = getDefaultPaths(nitro);
+	nitro.graphql ||= {
+		buildDir: "",
+		watchDirs: [],
+		clientDir: defaultPaths.clientDir,
+		serverDir: defaultPaths.serverDir,
+		dir: {
+			build: relative(nitro.options.rootDir, nitro.options.buildDir),
+			client: "graphql",
+			server: "server"
+		}
+	};
+	nitro.scanSchemas ||= [];
+	nitro.scanResolvers ||= [];
+	nitro.scanDirectives ||= [];
+	nitro.scanDocuments ||= [];
+}
+/**
+* Validate external services configuration
+*/
+function validateConfiguration(nitro) {
+	if (nitro.options.graphql?.externalServices?.length) {
+		const validationErrors = validateExternalServices(nitro.options.graphql.externalServices);
+		if (validationErrors.length > 0) {
+			logger.error("External services configuration errors:");
+			for (const error of validationErrors) logger.error(`  - ${error}`);
+			throw new Error("Invalid external services configuration");
+		}
+		logger.info(`Configured ${nitro.options.graphql.externalServices.length} external GraphQL services`);
+	}
+	if (nitro.options.graphql?.federation?.enabled) logger.info(`Apollo Federation enabled for service: ${nitro.options.graphql.federation.serviceName || "unnamed"}`);
+}
+/**
+* Setup build directories
+*/
+function setupBuildDirectories(nitro) {
+	const graphqlBuildDir = resolve(nitro.options.buildDir, "graphql");
+	nitro.graphql.buildDir = graphqlBuildDir;
+	switch (nitro.options.framework.name) {
+		case FRAMEWORK_NUXT:
+			nitro.graphql.dir.client = relative(nitro.options.rootDir, nitro.graphql.clientDir);
+			nitro.graphql.dir.server = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+			break;
+		case FRAMEWORK_NITRO:
+			nitro.graphql.dir.client = relative(nitro.options.rootDir, nitro.graphql.clientDir);
+			nitro.graphql.dir.server = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+			break;
+		default: break;
+	}
+}
+/**
+* Initialize runtime configuration
+*/
+function initializeRuntimeConfig(nitro) {
+	const securityConfig = resolveSecurityConfig(nitro.options.graphql?.security);
+	nitro.options.runtimeConfig.graphql = defu(nitro.options.runtimeConfig.graphql || {}, {
+		...DEFAULT_RUNTIME_CONFIG,
+		security: securityConfig
+	});
+}
+/**
+* Setup file watching for development mode
+*/
+function setupFileWatching(nitro, serverEnabled, extendDirs = []) {
+	const watchDirs = serverEnabled ? getWatchDirectories(nitro, extendDirs) : [nitro.graphql.clientDir].filter(Boolean);
+	nitro.graphql.watchDirs = watchDirs;
+	const watcher = setupFileWatcher(nitro, watchDirs);
+	nitro.hooks.hook("close", () => {
+		watcher.close();
+	});
+}
+/**
+* Scan all GraphQL files (schemas, resolvers, directives, documents)
+*/
+async function scanGraphQLFiles(nitro, serverEnabled) {
+	const skipLocalScan = nitro.options.graphql?.skipLocalScan === true;
+	const extendSources = nitro.options.graphql?.extend;
+	if (skipLocalScan && extendSources?.length) {
+		logger.info(`Using ${extendSources.length} extend source(s), skipping local scanning`);
+		nitro.scanSchemas = [];
+		nitro.scanResolvers = [];
+		nitro.scanDirectives = [];
+		nitro.scanDocuments = (await NitroAdapter.scanDocuments(nitro)).items;
+		return;
+	}
+	if (serverEnabled) await scanAllGraphQLFiles(nitro);
+	else nitro.scanDocuments = (await NitroAdapter.scanDocuments(nitro)).items;
+}
+/**
+* Setup dev mode hooks for rescanning files
+*/
+function setupDevHooks(nitro) {
+	let hasShownInitialLogs = false;
+	nitro.hooks.hook("dev:start", async () => {
+		await scanAllGraphQLFiles(nitro);
+		await resolveExtendConfig(nitro);
+		if (nitro.options.dev && !hasShownInitialLogs) {
+			hasShownInitialLogs = true;
+			logResolverDiagnostics(nitro);
+		}
+	});
+}
+/**
+* Log resolver diagnostics for development
+*/
+function logResolverDiagnostics(nitro) {
+	const resolvers = nitro.scanResolvers || [];
+	if (resolvers.length > 0) {
+		const totalExports = resolvers.reduce((sum, r) => sum + r.imports.length, 0);
+		const typeCount = {
+			query: 0,
+			mutation: 0,
+			resolver: 0,
+			type: 0,
+			subscription: 0,
+			directive: 0
+		};
+		for (const resolver of resolvers) for (const imp of resolver.imports) if (imp.type in typeCount) typeCount[imp.type]++;
+		const breakdown = [];
+		if (typeCount.query > 0) breakdown.push(`${typeCount.query} query`);
+		if (typeCount.mutation > 0) breakdown.push(`${typeCount.mutation} mutation`);
+		if (typeCount.resolver > 0) breakdown.push(`${typeCount.resolver} resolver`);
+		if (typeCount.type > 0) breakdown.push(`${typeCount.type} type`);
+		if (typeCount.subscription > 0) breakdown.push(`${typeCount.subscription} subscription`);
+		if (typeCount.directive > 0) breakdown.push(`${typeCount.directive} directive`);
+		if (breakdown.length > 0) logger.success(`${totalExports} resolver export(s): ${breakdown.join(", ")}`);
+	} else logger.warn("No resolvers found. Check /_nitro/graphql/debug for details.");
+}
+/**
+* Generate server and client types
+*/
+async function generateTypes(nitro, serverEnabled) {
+	if (serverEnabled) {
+		await generateServerTypes(nitro);
+		await generateClientTypes(nitro, { isInitial: true });
+	} else await generateClientTypes(nitro, { isInitial: true });
+}
+/**
+* Setup close hooks for final type generation
+*/
+function setupCloseHooks(nitro, serverEnabled) {
+	nitro.hooks.hook("close", async () => {
+		if (serverEnabled) await generateServerTypes(nitro, { silent: true });
+		await generateClientTypes(nitro, { silent: true });
+	});
+}
+/**
+* Setup TypeScript configuration and path aliases
+*/
+function setupTypeScriptConfiguration(nitro) {
+	nitro.options.typescript.strict = DEFAULT_TYPESCRIPT_STRICT;
+	nitro.hooks.hook("types:extend", (types) => {
+		setupTypeScriptPaths(nitro, types);
+	});
+}
+/**
+* Setup Nuxt-specific integration
+*/
+function setupNuxtIntegration(nitro) {
+	if (nitro.options.framework?.name === FRAMEWORK_NUXT && nitro.options.graphql?.externalServices?.length) nitro.hooks.hook("build:before", () => {
+		const nuxtOptions = nitro._nuxt?.options;
+		if (nuxtOptions) nuxtOptions.nitroGraphqlExternalServices = nitro.options.graphql?.externalServices || [];
+	});
+}
+
+//#endregion
+export { resolveSecurityConfig, setupNitroGraphQL };