nitro-graphql 2.0.0-beta.70 → 2.0.0-beta.73

package/dist/core/watcher/index.mjs

@@ -1,141 +1,2 @@
-import { DIRECTIVE_EXTENSIONS, GRAPHQL_EXTENSIONS, RESOLVER_EXTENSIONS } from "../constants.mjs";
-import { watch } from "chokidar";
-import { debounce } from "perfect-debounce";
-
-//#region src/core/watcher/index.ts
-/**
-* Check if a file is a GraphQL-related file
-*/
-function getFileType(path) {
-	if (GRAPHQL_EXTENSIONS.some((ext) => path.endsWith(ext))) return "graphql";
-	if (RESOLVER_EXTENSIONS.some((ext) => path.endsWith(ext))) return "resolver";
-	if (DIRECTIVE_EXTENSIONS.some((ext) => path.endsWith(ext))) return "directive";
-	return null;
-}
-/**
-* Check if a file should be watched
-*/
-function isWatchableFile(path) {
-	return getFileType(path) !== null;
-}
-/**
-* Classify a file change as server or client
-*/
-function classifyChange(path, serverDir) {
-	const fileType = getFileType(path);
-	if (!fileType) return null;
-	if (fileType === "resolver" || fileType === "directive") return "server";
-	if (fileType === "graphql") {
-		const normalizedPath = path.replace(/\\/g, "/");
-		const normalizedServerDir = serverDir.replace(/\\/g, "/");
-		if (normalizedPath.includes(normalizedServerDir)) return "server";
-		if (normalizedPath.includes("/server/graphql/") || normalizedPath.includes("\\server\\graphql\\")) return "server";
-		return "client";
-	}
-	return null;
-}
-/**
-* Create the ignored function for chokidar
-* Filters out non-GraphQL files and system directories
-*/
-function createIgnoredFunction() {
-	return (path) => {
-		if (path.includes("/node_modules/") || path.includes("/.git/") || path.includes("/.output/") || path.includes("/.nitro/") || path.includes("/.nuxt/") || path.includes("/.graphql/") || path.includes("/dist/")) return true;
-		if (!(path.split("/").pop() || "").includes(".") || path.endsWith("/")) return false;
-		return !isWatchableFile(path);
-	};
-}
-/**
-* Check if a path should be skipped (generated files)
-*/
-function shouldSkipPath(path) {
-	return path.includes("/sdk.ts") || path.includes("/sdk.js") || path.endsWith("/config.ts");
-}
-/**
-* Create a core file watcher
-*
-* This is the shared watcher used by both Nitro and CLI.
-* Framework-specific actions are passed as callbacks.
-*
-* @example
-* ```typescript
-* // In Nitro
-* const watcher = createCoreWatcher(
-*   { watchDirs, serverDir: nitro.graphql.serverDir },
-*   {
-*     onServerChange: async () => {
-*       await performGraphQLScan(nitro, { silent: true, isRescan: true })
-*       await generateServerTypes(nitro, { silent: true })
-*       await nitro.hooks.callHook('dev:reload')
-*     },
-*     onClientChange: async () => {
-*       await generateClientTypes(nitro, { silent: true })
-*     },
-*   }
-* )
-*
-* // In CLI
-* const watcher = createCoreWatcher(
-*   { watchDirs, serverDir: ctx.config.serverDir },
-*   {
-*     onServerChange: async () => {
-*       await generateAll(ctx, { silent: true })
-*       await reloadHandler()
-*     },
-*     onClientChange: async () => {
-*       await generateClient(ctx, { silent: true })
-*     },
-*   }
-* )
-* ```
-*/
-function createCoreWatcher(config, callbacks) {
-	const { watchDirs, serverDir, debounceMs = 150, persistent = true, ignoreInitial = true, usePolling } = config;
-	const shouldUsePolling = usePolling ?? (process.env.CI === "true" || process.env.VITE_TEST === "true");
-	const watcher = watch(watchDirs, {
-		persistent,
-		ignoreInitial,
-		ignored: createIgnoredFunction(),
-		usePolling: shouldUsePolling,
-		interval: shouldUsePolling ? 100 : void 0,
-		awaitWriteFinish: shouldUsePolling ? {
-			stabilityThreshold: 100,
-			pollInterval: 50
-		} : false
-	});
-	const pending = {
-		server: false,
-		client: false
-	};
-	async function processChanges() {
-		const changes = { ...pending };
-		pending.server = pending.client = false;
-		try {
-			if (changes.server) await callbacks.onServerChange();
-			else if (changes.client) await callbacks.onClientChange();
-		} catch (error) {
-			callbacks.onError?.(error);
-		}
-	}
-	const debouncedProcess = debounce(processChanges, debounceMs);
-	watcher.on("all", (_, path) => {
-		if (shouldSkipPath(path)) return;
-		const changeType = classifyChange(path, serverDir);
-		if (!changeType) return;
-		if (changeType === "server") pending.server = true;
-		else pending.client = true;
-		debouncedProcess();
-	});
-	if (callbacks.onReady) watcher.on("ready", callbacks.onReady);
-	if (callbacks.onError) watcher.on("error", callbacks.onError);
-	return watcher;
-}
-/**
-* Close a watcher safely
-*/
-async function closeWatcher(watcher) {
-	await watcher.close();
-}
-
-//#endregion
-export { classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath };
+import { classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath } from "./create-watcher.mjs";
+export { classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath };

package/dist/define.d.mts

@@ -1,5 +1,7 @@
-import { DefineDirectiveConfig, DefineServerConfig, DirectiveDefinition, Flatten, StandardSchemaV1 } from "./nitro/types.mjs";
-import { PubSubEngine, TypedPubSub, createPubSub, mapAsyncIterator, withFilter } from "./core/pubsub/index.mjs";
+import { DefineDirectiveConfig, DirectiveDefinition, Flatten } from "./core/types/define.mjs";
+import { StandardSchemaV1 } from "./core/types/standard-schema.mjs";
+import { DefineServerConfig } from "./nitro/types/define.mjs";
+import { PubSubEngine, TypedPubSub, createPubSub, mapAsyncIterator, withFilter } from "./core/pubsub/memory-pubsub.mjs";
 import { NPMConfig, Resolvers, ResolversTypes } from "#graphql/server";
 
 //#region src/define.d.ts

package/dist/define.mjs

@@ -1,5 +1,4 @@
-import { createPubSub, mapAsyncIterator, withFilter } from "./core/pubsub/index.mjs";
-
+import { createPubSub, mapAsyncIterator, withFilter } from "./core/pubsub/memory-pubsub.mjs";
 //#region src/define.ts
 /**
 * Define schema extensions programmatically for GraphQL types.
@@ -309,17 +308,17 @@ function defineDirective(config) {
 	const argsString = args ? `(${args})` : "";
 	const locations = config.locations.join(" | ");
 	const schemaDefinition = `directive @${config.name}${argsString} on ${locations}`;
-	Object.defineProperty(config, "__schema", {
+	const result = {
+		...config,
+		locations: [...config.locations]
+	};
+	Object.defineProperty(result, "__schema", {
 		value: schemaDefinition,
 		enumerable: false,
 		configurable: false,
 		writable: false
 	});
-	return {
-		...config,
-		locations: [...config.locations]
-	};
+	return result;
 }
-
 //#endregion
-export { createPubSub, defineDirective, defineField, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, mapAsyncIterator, withFilter };
+export { createPubSub, defineDirective, defineField, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, mapAsyncIterator, withFilter };

package/dist/index.d.mts

@@ -1,6 +1,7 @@
-import { ExternalGraphQLService, NitroGraphQLOptions, SecurityConfig } from "./nitro/types.mjs";
+import { CoreSecurityConfig } from "./core/types/config.mjs";
+import { ExternalGraphQLService, NitroGraphQLOptions } from "./nitro/types/config.mjs";
 import { NitroAdapter } from "./nitro/adapter.mjs";
-import { resolveSecurityConfig } from "./nitro/setup/logging.mjs";
+import { resolveSecurityConfig } from "./nitro/setup/security.mjs";
 import { setupNitroGraphQL } from "./nitro/setup.mjs";
 import graphqlModule from "./nitro/index.mjs";
-export { type ExternalGraphQLService, NitroAdapter, type NitroGraphQLOptions, type SecurityConfig, graphqlModule as default, resolveSecurityConfig, setupNitroGraphQL };
+export { type ExternalGraphQLService, NitroAdapter, type NitroGraphQLOptions, type CoreSecurityConfig as SecurityConfig, graphqlModule as default, resolveSecurityConfig, setupNitroGraphQL };

package/dist/index.mjs

@@ -1,6 +1,5 @@
 import { NitroAdapter } from "./nitro/adapter.mjs";
-import { resolveSecurityConfig } from "./nitro/setup/logging.mjs";
+import { resolveSecurityConfig } from "./nitro/setup/security.mjs";
 import { setupNitroGraphQL } from "./nitro/setup.mjs";
-import nitro_default from "./nitro/index.mjs";
-
-export { NitroAdapter, nitro_default as default, resolveSecurityConfig, setupNitroGraphQL };
+import graphqlModule from "./nitro/index.mjs";
+export { NitroAdapter, graphqlModule as default, resolveSecurityConfig, setupNitroGraphQL };

package/dist/nitro/adapter.d.mts

@@ -1,7 +1,6 @@
-import { CoreConfig, CoreContext, CoreLogger } from "../core/types/config.mjs";
+import { CoreConfig, CoreLogger } from "../core/types/config.mjs";
 import { ScanContext } from "../core/types/scanning.mjs";
-import "../core/types/index.mjs";
-import { FrameworkAdapter, ScanAdapter } from "../core/types/adapter.mjs";
+import { FrameworkAdapter } from "../core/types/adapter.mjs";
 import { Nitro } from "nitro/types";
 
 //#region src/nitro/adapter.d.ts
@@ -10,7 +9,7 @@ import { Nitro } from "nitro/types";
  */
 declare function createLoggerFromNitro(nitro: Nitro): CoreLogger;
 /**
- * Create a ScanContext from Nitro instance
+ * Create a ScanContext directly from Nitro instance
  */
 declare function createScanContextFromNitro(nitro: Nitro): ScanContext;
 /**
@@ -18,12 +17,8 @@ declare function createScanContextFromNitro(nitro: Nitro): ScanContext;
  */
 declare function createCoreConfigFromNitro(nitro: Nitro): CoreConfig;
 /**
- * Create a CoreContext from Nitro instance
+ * Nitro framework adapter
  */
-declare function createCoreContextFromNitro(nitro: Nitro): CoreContext;
-/**
- * Nitro framework adapter implementation
- */
-declare const NitroAdapter: FrameworkAdapter<Nitro> & ScanAdapter<Nitro>;
+declare const NitroAdapter: FrameworkAdapter<Nitro>;
 //#endregion
-export { NitroAdapter, NitroAdapter as default, createCoreConfigFromNitro, createCoreContextFromNitro, createLoggerFromNitro, createScanContextFromNitro };
+export { NitroAdapter, NitroAdapter as default, createCoreConfigFromNitro, createLoggerFromNitro, createScanContextFromNitro };

package/dist/nitro/adapter.mjs

@@ -1,9 +1,4 @@
-import { scanDirectivesCore } from "../core/scanning/directives.mjs";
-import { scanDocumentsCore } from "../core/scanning/documents.mjs";
-import { scanResolversCore } from "../core/scanning/resolvers.mjs";
-import { scanGraphqlCore, scanSchemasCore } from "../core/scanning/schemas.mjs";
-import { join, relative } from "pathe";
-
+import { join } from "pathe";
 //#region src/nitro/adapter.ts
 /**
 * Create a CoreLogger from Nitro's logger
@@ -18,7 +13,7 @@ function createLoggerFromNitro(nitro) {
 	};
 }
 /**
-* Create a ScanContext from Nitro instance
+* Create a ScanContext directly from Nitro instance
 */
 function createScanContextFromNitro(nitro) {
 	return {
@@ -35,59 +30,31 @@ function createScanContextFromNitro(nitro) {
 */
 function createCoreConfigFromNitro(nitro) {
 	const graphqlOptions = nitro.options.graphql || {};
-	const isNuxt = nitro.options.framework?.name === "nuxt";
-	const typesDir = join(nitro.graphql.buildDir, "types");
 	return {
 		rootDir: nitro.options.rootDir,
 		buildDir: nitro.graphql.buildDir,
 		serverDir: nitro.graphql.serverDir,
 		clientDir: nitro.graphql.clientDir,
-		typesDir,
+		typesDir: join(nitro.graphql.buildDir, "types"),
 		framework: graphqlOptions.framework || "graphql-yoga",
-		isNuxt,
+		isNuxt: nitro.options.framework?.name === "nuxt",
 		isDev: nitro.options.dev,
-		graphqlOptions: {
-			framework: graphqlOptions.framework,
-			endpoint: typeof graphqlOptions.endpoint === "object" ? graphqlOptions.endpoint?.graphql : graphqlOptions.endpoint,
-			federation: graphqlOptions.federation,
-			security: graphqlOptions.security
-		},
 		logger: createLoggerFromNitro(nitro),
-		ignorePatterns: nitro.options.ignore
-	};
-}
-/**
-* Create a CoreContext from Nitro instance
-*/
-function createCoreContextFromNitro(nitro) {
-	return {
-		config: createCoreConfigFromNitro(nitro),
-		graphqlBuildDir: nitro.graphql.buildDir,
-		watchDirs: nitro.graphql.watchDirs,
-		dir: nitro.graphql.dir
+		ignorePatterns: nitro.options.ignore,
+		security: graphqlOptions.security,
+		federation: graphqlOptions.federation,
+		codegen: graphqlOptions.codegen,
+		externalServices: graphqlOptions.externalServices
 	};
 }
 /**
-* Nitro framework adapter implementation
+* Nitro framework adapter
 */
 const NitroAdapter = {
 	name: "nitro",
 	createCoreConfig: createCoreConfigFromNitro,
-	createCoreContext: createCoreContextFromNitro,
 	createScanContext: createScanContextFromNitro,
-	getLogger: createLoggerFromNitro,
-	scanSchemas: (nitro) => scanSchemasCore(createScanContextFromNitro(nitro)),
-	scanGraphql: (nitro) => scanGraphqlCore(createScanContextFromNitro(nitro)),
-	scanResolvers: (nitro) => scanResolversCore(createScanContextFromNitro(nitro)),
-	scanDirectives: (nitro) => scanDirectivesCore(createScanContextFromNitro(nitro)),
-	scanDocuments(nitro) {
-		return scanDocumentsCore(createScanContextFromNitro(nitro), {
-			externalServices: nitro.options.graphql?.externalServices,
-			clientDirRelative: relative(nitro.options.rootDir, nitro.graphql.clientDir)
-		});
-	}
+	getLogger: createLoggerFromNitro
 };
-var adapter_default = NitroAdapter;
-
 //#endregion
-export { NitroAdapter, createCoreConfigFromNitro, createCoreContextFromNitro, createLoggerFromNitro, createScanContextFromNitro, adapter_default as default };
+export { NitroAdapter, NitroAdapter as default, createCoreConfigFromNitro, createLoggerFromNitro, createScanContextFromNitro };

package/dist/nitro/apollo.mjs

@@ -1,6 +1,5 @@
 import { HeaderMap } from "@apollo/server";
 import { eventHandler, getRequestURL, readBody } from "nitro/h3";
-
 //#region src/nitro/apollo.ts
 function startServerAndCreateH3Handler(server, options) {
 	const defaultContext = () => Promise.resolve({});
@@ -54,6 +53,5 @@ async function normalizeBody(event) {
 	const method = event.req.method;
 	if (method && PayloadMethods.includes(method)) return await readBody(event);
 }
-
 //#endregion
-export { startServerAndCreateH3Handler };
+export { startServerAndCreateH3Handler };

package/dist/nitro/codegen/client-types.d.mts

@@ -0,0 +1,12 @@
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/codegen/client-types.d.ts
+/**
+ * Generate client-side operation types
+ */
+declare function generateClientTypes(nitro: Nitro, options?: {
+  silent?: boolean;
+  isInitial?: boolean;
+}, schemaString?: string): Promise<void>;
+//#endregion
+export { generateClientTypes };

package/dist/nitro/codegen/client-types.mjs

@@ -0,0 +1,73 @@
+import { LOG_TAG } from "../../core/constants.mjs";
+import { generateClientTypesCore } from "../../core/codegen/client.mjs";
+import { loadGraphQLDocuments } from "../../core/codegen/document-loader.mjs";
+import { writeFile } from "../../core/utils/file-io.mjs";
+import { generateSubscriptionBuilder } from "../../core/codegen/vue-subscription-builder.mjs";
+import { getDefaultPaths, getSdkConfig, getTypesConfig, resolveFilePath } from "../paths.mjs";
+import { subscribeClientTemplate } from "../../core/utils/subscribe-templates.mjs";
+import { generateExternalTypes } from "./external-types.mjs";
+import consola from "consola";
+import { join } from "pathe";
+import { existsSync, readFileSync } from "node:fs";
+//#region src/nitro/codegen/client-types.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Generate client-side operation types
+*/
+async function generateClientTypes(nitro, options = {}, schemaString) {
+	try {
+		if (nitro.graphql.state.schemas.length) await generateMainClientTypes(nitro, options, schemaString);
+		if (nitro.options.graphql?.externalServices?.length) await generateExternalTypes(nitro, options);
+	} catch (error) {
+		logger.error("Client type generation failed:", error);
+	}
+}
+async function generateMainClientTypes(nitro, options = {}, schemaString) {
+	if (!schemaString) {
+		const schemaPath = join(nitro.graphql.buildDir, "schema.graphql");
+		if (!existsSync(schemaPath)) {
+			if (!options.silent) consola.info("Schema not ready for client types");
+			return;
+		}
+		schemaString = readFileSync(schemaPath, "utf-8");
+	}
+	const docs = await loadGraphQLDocuments([...nitro.graphql.state.documents]);
+	const serverScalars = nitro.options.graphql?.codegen?.server?.scalars;
+	const clientConfig = nitro.options.graphql?.codegen?.client || {};
+	const resolvedClientConfig = {
+		...clientConfig,
+		scalars: clientConfig.scalars ?? serverScalars
+	};
+	const types = await generateClientTypesCore({
+		schemaString,
+		documents: docs,
+		config: resolvedClientConfig,
+		sdkConfig: nitro.options.graphql?.codegen?.clientSDK,
+		options
+	});
+	if (types === false) return;
+	const placeholders = getDefaultPaths(nitro);
+	const typesConfig = getTypesConfig(nitro);
+	const sdkFileConfig = getSdkConfig(nitro);
+	const subscriptionsEnabled = nitro.options.graphql?.subscriptions?.enabled ?? false;
+	const clientPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
+	if (clientPath) {
+		writeFile(clientPath, types.types);
+		if (!options.silent) logger.success(`Client types: ${clientPath}`);
+	}
+	const subscriptionCode = generateSubscriptionBuilder(docs, subscriptionsEnabled);
+	const sdkPath = resolveFilePath(sdkFileConfig.main, sdkFileConfig.enabled, true, "{clientDir}/default/sdk.ts", placeholders);
+	if (sdkPath) {
+		writeFile(sdkPath, subscriptionCode ? types.sdk + subscriptionCode : types.sdk);
+		if (!options.silent) logger.success(`SDK: ${sdkPath}`);
+	}
+	if (subscriptionsEnabled) {
+		const subscribePath = resolveFilePath(true, true, true, "{clientDir}/default/subscribe.ts", placeholders);
+		if (subscribePath && !existsSync(subscribePath)) {
+			writeFile(subscribePath, subscribeClientTemplate);
+			if (!options.silent) logger.success(`Subscribe config: ${subscribePath}`);
+		}
+	}
+}
+//#endregion
+export { generateClientTypes };

package/dist/nitro/codegen/external-types.d.mts

@@ -0,0 +1,8 @@
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/codegen/external-types.d.ts
+declare function generateExternalTypes(nitro: Nitro, options?: {
+  silent?: boolean;
+}): Promise<void>;
+//#endregion
+export { generateExternalTypes };

package/dist/nitro/codegen/external-types.mjs

@@ -0,0 +1,47 @@
+import { generateExternalClientTypesCore } from "../../core/codegen/client.mjs";
+import { loadGraphQLDocuments } from "../../core/codegen/document-loader.mjs";
+import { writeFile } from "../../core/utils/file-io.mjs";
+import { downloadAndSaveSchema, loadExternalSchema } from "../../core/codegen/schema-loader.mjs";
+import { getDefaultPaths, getSdkConfig, getTypesConfig, resolveFilePath } from "../paths.mjs";
+import consola from "consola";
+//#region src/nitro/codegen/external-types.ts
+async function generateExternalServiceTypes(nitro, service, options = {}) {
+	if (!options.silent) consola.info(`[${service.name}] Processing external service`);
+	await downloadAndSaveSchema(service, nitro.options.buildDir);
+	const schema = await loadExternalSchema(service, nitro.options.buildDir);
+	if (!schema) {
+		consola.warn(`[${service.name}] Failed to load schema`);
+		return;
+	}
+	const docs = service.documents?.length ? await loadGraphQLDocuments(service.documents).catch(() => []) : [];
+	if (service.documents?.length && !docs.length) {
+		consola.warn(`[${service.name}] No documents found`);
+		return;
+	}
+	const types = await generateExternalClientTypesCore(service, schema, docs);
+	if (types === false) return;
+	const placeholders = {
+		...getDefaultPaths(nitro),
+		serviceName: service.name
+	};
+	const typesConfig = getTypesConfig(nitro);
+	const sdkFileConfig = getSdkConfig(nitro);
+	const typesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", placeholders);
+	if (typesPath) {
+		writeFile(typesPath, types.types);
+		if (!options.silent) consola.success(`[${service.name}] Types: ${typesPath}`);
+	}
+	const sdkPath = resolveFilePath(service.paths?.sdk ?? sdkFileConfig.external, sdkFileConfig.enabled, true, "{clientDir}/{serviceName}/sdk.ts", placeholders);
+	if (sdkPath) {
+		writeFile(sdkPath, types.sdk);
+		if (!options.silent) consola.success(`[${service.name}] SDK: ${sdkPath}`);
+	}
+}
+async function generateExternalTypes(nitro, options = {}) {
+	const services = nitro.options.graphql?.externalServices || [];
+	await Promise.all(services.map((service) => generateExternalServiceTypes(nitro, service, options).catch((error) => {
+		consola.error(`[${service.name}] External service failed:`, error);
+	})));
+}
+//#endregion
+export { generateExternalTypes };

package/dist/nitro/codegen/index.d.mts

@@ -0,0 +1,4 @@
+import { generateClientTypes } from "./client-types.mjs";
+import { generateExternalTypes } from "./external-types.mjs";
+import { generateServerTypes } from "./server-types.mjs";
+export { generateClientTypes, generateExternalTypes, generateServerTypes };

package/dist/nitro/codegen/index.mjs

@@ -0,0 +1,4 @@
+import { generateExternalTypes } from "./external-types.mjs";
+import { generateClientTypes } from "./client-types.mjs";
+import { generateServerTypes } from "./server-types.mjs";
+export { generateClientTypes, generateExternalTypes, generateServerTypes };

package/dist/nitro/codegen/server-types.d.mts

@@ -0,0 +1,12 @@
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/codegen/server-types.d.ts
+/**
+ * Generate server-side resolver types
+ * Returns the sorted schema string for reuse by client type generation
+ */
+declare function generateServerTypes(nitro: Nitro, options?: {
+  silent?: boolean;
+}): Promise<string | undefined>;
+//#endregion
+export { generateServerTypes };

package/dist/nitro/codegen/server-types.mjs

@@ -0,0 +1,81 @@
+import { LOG_TAG } from "../../core/constants.mjs";
+import { writeFile } from "../../core/utils/file-io.mjs";
+import { generateServerTypesCore } from "../../core/codegen/server.mjs";
+import { validateNoDuplicateTypes } from "../../core/codegen/validation.mjs";
+import { loadFederationSupport } from "../../core/schema/federation.mjs";
+import { getDefaultPaths, getTypesConfig, resolveFilePath, shouldGenerateTypes } from "../paths.mjs";
+import consola from "consola";
+import { resolve } from "pathe";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { parse, print } from "graphql";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+import { makeExecutableSchema } from "@graphql-tools/schema";
+import { loadFilesSync } from "@graphql-tools/load-files";
+//#region src/nitro/codegen/server-types.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Build schema with optional federation support
+* Uses @graphql-tools to ensure same graphql instance is used throughout
+*/
+async function buildSchemaFromString(source, federation) {
+	if (federation) {
+		const buildSubgraph = await loadFederationSupport();
+		if (!buildSubgraph) throw new Error("Federation enabled but @apollo/subgraph not installed");
+		return buildSubgraph([{ typeDefs: parse(source) }]);
+	}
+	return makeExecutableSchema({ typeDefs: source });
+}
+/**
+* Generate server-side resolver types
+* Returns the sorted schema string for reuse by client type generation
+*/
+async function generateServerTypes(nitro, options = {}) {
+	if (!shouldGenerateTypes(nitro)) return;
+	const schemas = nitro.graphql.state.schemas;
+	if (!schemas.length) {
+		if (!options.silent) consola.info("No GraphQL schemas found");
+		return;
+	}
+	try {
+		const allStrings = loadFilesSync(schemas).map((s) => typeof s === "string" ? s : s.loc?.source?.body || "");
+		const validSchemas = [];
+		const strings = [];
+		schemas.forEach((schema, i) => {
+			if (allStrings[i]) {
+				validSchemas.push(schema);
+				strings.push(allStrings[i]);
+			}
+		});
+		const directiveSchemas = nitro.graphql.state.directiveSchemas;
+		if (directiveSchemas) {
+			validSchemas.push("<inline-directives>");
+			strings.push(directiveSchemas);
+		}
+		if (!validateNoDuplicateTypes(validSchemas, strings)) return;
+		const mergedSchemaString = print(mergeTypeDefs([strings.join("\n\n")], {
+			throwOnConflict: true,
+			sort: true
+		}));
+		const federation = nitro.options.graphql?.federation?.enabled === true;
+		const sortedSchemaString = printSchemaWithDirectives(await buildSchemaFromString(mergedSchemaString, federation));
+		const result = await generateServerTypesCore({
+			framework: nitro.options.graphql?.framework || "graphql-yoga",
+			schemaString: sortedSchemaString,
+			config: nitro.options.graphql?.codegen?.server,
+			federationEnabled: federation
+		});
+		writeFile(resolve(nitro.graphql.buildDir, "schema.graphql"), sortedSchemaString);
+		const placeholders = getDefaultPaths(nitro);
+		const typesConfig = getTypesConfig(nitro);
+		const typesPath = resolveFilePath(typesConfig.server, typesConfig.enabled, true, "{typesDir}/nitro-graphql-server.d.ts", placeholders);
+		if (typesPath) {
+			writeFile(typesPath, result.types);
+			if (!options.silent) logger.success(`Server types: ${typesPath}`);
+		}
+		return sortedSchemaString;
+	} catch (error) {
+		logger.error("Server type generation failed:", error);
+	}
+}
+//#endregion
+export { generateServerTypes };

package/dist/nitro/defaults.d.mts

@@ -0,0 +1,28 @@
+import { NitroGraphQLOptions } from "./types/config.mjs";
+//#region src/nitro/defaults.d.ts
+/**
+ * Default type generation configuration
+ */
+declare const DEFAULT_TYPES_CONFIG: {
+  readonly server: ".graphql/nitro-graphql-server.d.ts";
+  readonly client: ".graphql/nitro-graphql-client.d.ts";
+  readonly enabled: true;
+};
+/**
+ * Default runtime GraphQL configuration
+ */
+declare const DEFAULT_RUNTIME_CONFIG: NitroGraphQLOptions;
+/**
+ * Default SDK configuration
+ */
+declare const DEFAULT_SDK_CONFIG: {
+  readonly enabled: true;
+  readonly main: true;
+  readonly external: true;
+};
+/**
+ * Default TypeScript strict mode setting
+ */
+declare const DEFAULT_TYPESCRIPT_STRICT: true;
+//#endregion
+export { DEFAULT_RUNTIME_CONFIG, DEFAULT_SDK_CONFIG, DEFAULT_TYPESCRIPT_STRICT, DEFAULT_TYPES_CONFIG };

package/dist/nitro/defaults.mjs

@@ -0,0 +1,34 @@
+import { DEFAULT_CLIENT_TYPES_PATH, DEFAULT_SERVER_TYPES_PATH, ENDPOINT_GRAPHQL, ENDPOINT_HEALTH } from "../core/constants.mjs";
+//#region src/nitro/defaults.ts
+/**
+* Default type generation configuration
+*/
+const DEFAULT_TYPES_CONFIG = {
+	server: DEFAULT_SERVER_TYPES_PATH,
+	client: DEFAULT_CLIENT_TYPES_PATH,
+	enabled: true
+};
+/**
+* Default runtime GraphQL configuration
+*/
+const DEFAULT_RUNTIME_CONFIG = {
+	endpoint: {
+		graphql: ENDPOINT_GRAPHQL,
+		healthCheck: ENDPOINT_HEALTH
+	},
+	playground: true
+};
+/**
+* Default SDK configuration
+*/
+const DEFAULT_SDK_CONFIG = {
+	enabled: true,
+	main: true,
+	external: true
+};
+/**
+* Default TypeScript strict mode setting
+*/
+const DEFAULT_TYPESCRIPT_STRICT = true;
+//#endregion
+export { DEFAULT_RUNTIME_CONFIG, DEFAULT_SDK_CONFIG, DEFAULT_TYPESCRIPT_STRICT, DEFAULT_TYPES_CONFIG };