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

package/dist/nitro/adapter.d.mts

@@ -1,6 +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 { 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
@@ -9,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;
 /**
@@ -17,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,8 +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
@@ -17,7 +13,7 @@ function createLoggerFromNitro(nitro) {
 	};
 }
 /**
-* Create a ScanContext from Nitro instance
+* Create a ScanContext directly from Nitro instance
 */
 function createScanContextFromNitro(nitro) {
 	return {
@@ -34,57 +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
 };
 //#endregion
-export { NitroAdapter, NitroAdapter as default, createCoreConfigFromNitro, createCoreContextFromNitro, createLoggerFromNitro, createScanContextFromNitro };
+export { NitroAdapter, NitroAdapter as default, createCoreConfigFromNitro, createLoggerFromNitro, createScanContextFromNitro };

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 };

package/dist/nitro/index.d.mts

@@ -1,6 +1,14 @@
-import { ClientUtilsConfig, CodegenClientConfig, CodegenServerConfig, DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, ExplicitPathsExtendSource, ExtendSource, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, Flatten, GenImport, GenericSdkConfig, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, LocalDirExtendSource, NitroGraphQLOptions, PathsConfig, PubSubConfig, RuntimeConfig, SSETransportConfig, SdkConfig, SecurityConfig, StandardSchemaV1, SubscriptionsConfig, TypesConfig, WatchConfig, WebSocketTransportConfig } from "./types.mjs";
+import { ClientCodegenConfig, ExternalServiceCodegenConfig, SdkCodegenConfig, ServerCodegenConfig } from "../core/types/codegen.mjs";
+import { CoreSecurityConfig } from "../core/types/config.mjs";
+import { ResolverImport, ScannedResolver } from "../core/types/scanning.mjs";
+import { DefineDirectiveConfig, DirectiveArg, DirectiveArgument, DirectiveDefinition, DirectiveLocationName, Flatten, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType } from "../core/types/define.mjs";
+import { StandardSchemaV1 } from "../core/types/standard-schema.mjs";
+import { DefineServerConfig } from "./types/define.mjs";
+import { LocalDirExtendSource } from "../core/extend/loader.mjs";
+import { CLIGraphQLOptions, ClientUtilsConfig, ExplicitPathsExtendSource, ExtendSource, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, NitroGraphQLOptions, PathsConfig, PubSubConfig, RuntimeConfig, SSETransportConfig, SdkConfig, SubscriptionsConfig, TypesConfig, WatchConfig, WebSocketTransportConfig } from "./types/config.mjs";
+import { GraphQLScanState } from "./types/augmentation.mjs";
 import { NitroAdapter } from "./adapter.mjs";
-import { resolveSecurityConfig } from "./setup/logging.mjs";
+import { resolveSecurityConfig } from "./setup/security.mjs";
 import { setupNitroGraphQL } from "./setup.mjs";
 import { NitroModule } from "nitro/types";
 import { Plugin } from "vite";
@@ -42,4 +50,4 @@ declare function graphqlModule(options?: NitroGraphQLOptions): Plugin & {
   nitro: NitroModule;
 };
 //#endregion
-export { ClientUtilsConfig, CodegenClientConfig, CodegenServerConfig, DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, ExplicitPathsExtendSource, ExtendSource, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, Flatten, GenImport, GenericSdkConfig, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, LocalDirExtendSource, NitroAdapter, NitroGraphQLOptions, PathsConfig, PubSubConfig, RuntimeConfig, SSETransportConfig, SdkConfig, SecurityConfig, StandardSchemaV1, SubscriptionsConfig, TypesConfig, WatchConfig, WebSocketTransportConfig, graphqlModule as default, resolveSecurityConfig, setupNitroGraphQL };
+export { CLIGraphQLOptions, ClientCodegenConfig, ClientUtilsConfig, ClientCodegenConfig as CodegenClientConfig, ServerCodegenConfig as CodegenServerConfig, DefineDirectiveConfig, DefineServerConfig, DirectiveArg, DirectiveArgument, DirectiveDefinition, DirectiveLocationName, ExplicitPathsExtendSource, ExtendSource, ExternalGraphQLService, ExternalServiceCodegenConfig, ExternalServicePaths, FederationConfig, FileGenerationConfig, Flatten, SdkCodegenConfig as GenericSdkConfig, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, GraphQLScanState, LocalDirExtendSource, NitroAdapter, NitroGraphQLOptions, PathsConfig, PubSubConfig, ResolverImport, RuntimeConfig, SSETransportConfig, ScannedResolver, SdkCodegenConfig, SdkConfig, CoreSecurityConfig as SecurityConfig, ServerCodegenConfig, StandardSchemaV1, SubscriptionsConfig, TypesConfig, WatchConfig, WebSocketTransportConfig, graphqlModule as default, resolveSecurityConfig, setupNitroGraphQL };

package/dist/nitro/index.mjs

@@ -1,5 +1,5 @@
 import { NitroAdapter } from "./adapter.mjs";
-import { resolveSecurityConfig } from "./setup/logging.mjs";
+import { resolveSecurityConfig } from "./setup/security.mjs";
 import { setupNitroGraphQL } from "./setup.mjs";
 import { readFile } from "node:fs/promises";
 import defu from "defu";

package/dist/nitro/paths.d.mts

@@ -1,4 +1,4 @@
-import { FileGenerationConfig, SdkConfig, TypesConfig } from "./types.mjs";
+import { FileGenerationConfig, SdkConfig, TypesConfig } from "./types/config.mjs";
 import { Nitro } from "nitro/types";
 
 //#region src/nitro/paths.d.ts
@@ -16,7 +16,8 @@ interface PathPlaceholders {
 }
 /**
  * Replace placeholders in a path string
- * Supports: {serviceName}, {buildDir}, {rootDir}, {framework}, {typesDir}, {serverDir}, {clientDir}
+ * Matches any `{key}` and resolves from the placeholders record.
+ * Unknown keys pass through unchanged. `{serviceName}` defaults to 'default'.
  */
 declare function replacePlaceholders(path: string, placeholders: PathPlaceholders): string;
 /**

package/dist/nitro/paths.mjs

@@ -1,18 +1,22 @@
 import { isAbsolute, resolve } from "pathe";
 //#region src/nitro/paths.ts
-const SERVICE_NAME_RE = /\{serviceName\}/g;
-const BUILD_DIR_RE = /\{buildDir\}/g;
-const ROOT_DIR_RE = /\{rootDir\}/g;
-const FRAMEWORK_RE = /\{framework\}/g;
-const TYPES_DIR_RE = /\{typesDir\}/g;
-const SERVER_DIR_RE = /\{serverDir\}/g;
-const CLIENT_DIR_RE = /\{clientDir\}/g;
+const PLACEHOLDER_RE = /\{(\w+)\}/g;
 /**
 * Replace placeholders in a path string
-* Supports: {serviceName}, {buildDir}, {rootDir}, {framework}, {typesDir}, {serverDir}, {clientDir}
+* Matches any `{key}` and resolves from the placeholders record.
+* Unknown keys pass through unchanged. `{serviceName}` defaults to 'default'.
 */
 function replacePlaceholders(path, placeholders) {
-	return path.replace(SERVICE_NAME_RE, placeholders.serviceName || "default").replace(BUILD_DIR_RE, placeholders.buildDir).replace(ROOT_DIR_RE, placeholders.rootDir).replace(FRAMEWORK_RE, placeholders.framework).replace(TYPES_DIR_RE, placeholders.typesDir).replace(SERVER_DIR_RE, placeholders.serverDir).replace(CLIENT_DIR_RE, placeholders.clientDir);
+	const lookup = {
+		serviceName: placeholders.serviceName || "default",
+		buildDir: placeholders.buildDir,
+		rootDir: placeholders.rootDir,
+		framework: placeholders.framework,
+		typesDir: placeholders.typesDir,
+		serverDir: placeholders.serverDir,
+		clientDir: placeholders.clientDir
+	};
+	return path.replace(PLACEHOLDER_RE, (match, key) => lookup[key] ?? match);
 }
 /**
 * Get default paths based on framework and user configuration

package/dist/nitro/rollup.mjs

@@ -1,5 +1,6 @@
-import { NitroAdapter } from "./adapter.mjs";
-import { registerAllVirtualModules } from "./virtual/generators.mjs";
+import { scanSchemasCore } from "../core/scanning/schemas.mjs";
+import { createScanContextFromNitro } from "./adapter.mjs";
+import { registerAllVirtualModules } from "./virtual/index.mjs";
 import { readFile } from "node:fs/promises";
 import { parse } from "graphql";
 //#region src/nitro/rollup.ts
@@ -40,7 +41,7 @@ async function rollupConfig(nitro) {
 				buildStart: {
 					order: "pre",
 					async handler() {
-						const result = await NitroAdapter.scanGraphql(nitro);
+						const result = await scanSchemasCore(createScanContextFromNitro(nitro));
 						for (const file of result.items) this.addWatchFile(file);
 					}
 				}

package/dist/nitro/routes/_ws-handler.d.mts

@@ -0,0 +1,6 @@
+import { Hooks } from "crossws";
+
+//#region src/nitro/routes/_ws-handler.d.ts
+declare const wsHooks: Partial<Hooks>;
+//#endregion
+export { wsHooks };

package/dist/nitro/routes/_ws-handler.mjs

@@ -0,0 +1,49 @@
+import { createMergedSchema } from "../../core/schema/builder.mjs";
+import { handleProtocols } from "graphql-ws";
+import { makeHooks } from "graphql-ws/use/crossws";
+import { importedConfig } from "#nitro-graphql/graphql-config";
+import { moduleConfig } from "#nitro-graphql/module-config";
+import { directives } from "#nitro-graphql/server-directives";
+import { resolvers } from "#nitro-graphql/server-resolvers";
+import { schemas } from "#nitro-graphql/server-schemas";
+//#region src/nitro/routes/_ws-handler.ts
+let schema = null;
+/**
+* Get or create the merged GraphQL schema
+*/
+async function getSchema() {
+	if (!schema) schema = await createMergedSchema({
+		schemas,
+		resolvers,
+		directives,
+		moduleConfig
+	});
+	return schema;
+}
+const wsHooks = {
+	upgrade(request) {
+		const selected = handleProtocols(request.headers.get("sec-websocket-protocol") || "");
+		if (selected) return { headers: { "Sec-WebSocket-Protocol": selected } };
+		return {};
+	},
+	...makeHooks({
+		schema: () => getSchema(),
+		context: async (ctx) => {
+			const baseContext = { connectionParams: ctx.connectionParams };
+			if (typeof importedConfig.context === "function") {
+				const userContext = await importedConfig.context(baseContext);
+				return {
+					...baseContext,
+					...userContext
+				};
+			}
+			if (importedConfig.context && typeof importedConfig.context === "object") return {
+				...baseContext,
+				...importedConfig.context
+			};
+			return baseContext;
+		}
+	})
+};
+//#endregion
+export { wsHooks };

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

@@ -3,7 +3,7 @@ import * as nitro_h30 from "nitro/h3";
 //#region src/nitro/routes/apollo-server-ws.d.ts
 /**
  * Apollo Server WebSocket handler for subscriptions
- * Uses graphql-ws library with crossws adapter for proper protocol handling
+ * Uses shared WebSocket handler with graphql-ws and crossws
  *
  * Note: This handler works independently from Apollo Server for subscriptions,
  * as Apollo Server v5 requires separate WebSocket handling.