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

package/dist/core/codegen/client.mjs

@@ -1,7 +1,5 @@
 import { DEFAULT_GRAPHQL_SCALARS } from "../constants.mjs";
-import { pluginContent } from "./plugin.mjs";
-import { loadGraphQLDocuments } from "./document-loader.mjs";
-import { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
+import { GENERATED_FILE_HEADER } from "./file-header.mjs";
 import { defu as defu$1 } from "defu";
 import consola from "consola";
 import { codegen } from "@graphql-codegen/core";
@@ -11,7 +9,7 @@ import { plugin as plugin$1 } from "@graphql-codegen/typescript";
 import { plugin as plugin$2 } from "@graphql-codegen/typescript-generic-sdk";
 import { plugin as plugin$3 } from "@graphql-codegen/typescript-operations";
 import { printSchemaWithDirectives } from "@graphql-tools/utils";
-import { Kind, parse } from "graphql";
+import { parse } from "graphql";
 //#region src/core/codegen/client.ts
 /**
 * Default client codegen configuration
@@ -23,22 +21,16 @@ const DEFAULT_CLIENT_CODEGEN_CONFIG = {
 	strictScalars: true,
 	maybeValue: "T | null | undefined",
 	inputMaybeValue: "T | undefined",
-	documentMode: "string",
 	pureMagicComment: true,
 	dedupeOperationSuffix: true,
 	rawRequest: true,
 	scalars: DEFAULT_GRAPHQL_SCALARS
 };
 /**
-* Generate generic SDK content for schema-only generation
+* Generate generic SDK stub for schema-only generation (no documents)
 */
 function generateGenericSdkContent() {
-	return `// THIS FILE IS GENERATED, DO NOT EDIT!
-/* eslint-disable eslint-comments/no-unlimited-disable */
-/* tslint:disable */
-/* eslint-disable */
-/* prettier-ignore */
-
+	return `${GENERATED_FILE_HEADER}
 import type { GraphQLResolveInfo } from 'graphql'
 export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> }
 
@@ -61,38 +53,30 @@ export function getSdk(requester: Requester): Sdk {
 }
 /**
 * Generate client-side GraphQL types
-* Pure function that generates TypeScript types from a GraphQL schema and documents
 */
 async function generateClientTypesCore(input) {
 	const { schema, schemaString, documents, config = {}, sdkConfig = {}, outputPath, serviceName, virtualTypesPath } = input;
 	if (documents.length === 0 && !serviceName) return false;
 	const schemaSDL = schemaString || (schema ? printSchemaWithDirectives(schema) : null);
 	if (!schemaSDL) return false;
-	const mergedConfig = defu$1(DEFAULT_CLIENT_CODEGEN_CONFIG, config);
-	const mergedSdkConfig = defu$1(mergedConfig, sdkConfig);
+	const mergedConfig = defu$1(config, DEFAULT_CLIENT_CODEGEN_CONFIG);
+	const resolvedSdkConfig = defu$1(sdkConfig, mergedConfig);
+	const parsedSchema = parse(schemaSDL);
 	try {
 		if (documents.length === 0) return {
-			types: await codegen({
+			types: GENERATED_FILE_HEADER + await codegen({
 				filename: outputPath || "client-types.generated.ts",
-				schema: parse(schemaSDL),
+				schema: parsedSchema,
 				documents: [],
 				config: mergedConfig,
-				plugins: [{ pluginContent: {} }, { typescript: {} }],
-				pluginMap: {
-					pluginContent: { plugin: pluginContent },
-					typescript: { plugin: plugin$1 }
-				}
+				plugins: [{ typescript: {} }],
+				pluginMap: { typescript: { plugin: plugin$1 } }
 			}),
 			sdk: generateGenericSdkContent()
 		};
 		const enableTypedDocumentNode = config.typedDocumentNode === true;
-		const plugins = [
-			{ pluginContent: {} },
-			{ typescript: {} },
-			{ typescriptOperations: {} }
-		];
+		const plugins = [{ typescript: {} }, { typescriptOperations: {} }];
 		const pluginMap = {
-			pluginContent: { plugin: pluginContent },
 			typescript: { plugin: plugin$1 },
 			typescriptOperations: { plugin: plugin$3 }
 		};
@@ -100,9 +84,9 @@ async function generateClientTypesCore(input) {
 			plugins.push({ typedDocumentNode: {} });
 			pluginMap.typedDocumentNode = { plugin };
 		}
-		const output = await codegen({
+		const generated = await codegen({
 			filename: outputPath || "client-types.generated.ts",
-			schema: parse(schemaSDL),
+			schema: parsedSchema,
 			documents: [...documents],
 			config: mergedConfig,
 			plugins,
@@ -111,24 +95,20 @@ async function generateClientTypesCore(input) {
 		const typesPath = virtualTypesPath || (serviceName ? `#graphql/client/${serviceName}` : "#graphql/client");
 		const sdkOutput = await preset.buildGeneratesSection({
 			baseOutputDir: outputPath || "client-types.generated.ts",
-			schema: parse(schemaSDL),
+			schema: parsedSchema,
 			documents: [...documents],
-			config: mergedSdkConfig,
+			config: resolvedSdkConfig,
 			presetConfig: { typesPath },
-			plugins: [{ pluginContent: {} }, { typescriptGenericSdk: {} }],
-			pluginMap: {
-				pluginContent: { plugin: pluginContent },
-				typescriptGenericSdk: { plugin: plugin$2 }
-			}
+			plugins: [{ typescriptGenericSdk: {} }],
+			pluginMap: { typescriptGenericSdk: { plugin: plugin$2 } }
 		});
+		const results = await Promise.all(sdkOutput.map(async (config) => ({
+			file: config.filename,
+			content: await codegen(config)
+		})));
 		return {
-			types: output,
-			sdk: (await Promise.all(sdkOutput.map(async (config) => {
-				return {
-					file: config.filename,
-					content: await codegen(config)
-				};
-			})))[0]?.content || ""
+			types: GENERATED_FILE_HEADER + generated,
+			sdk: GENERATED_FILE_HEADER + (results[0]?.content || "")
 		};
 	} catch (error) {
 		consola.error("[nitro-graphql] Client type generation failed:", error.message);
@@ -136,7 +116,7 @@ async function generateClientTypesCore(input) {
 	}
 }
 /**
-* Generate client types for external GraphQL service
+* Generate client types for an external GraphQL service
 */
 async function generateExternalClientTypesCore(service, schema, documents, virtualTypesPath) {
 	return generateClientTypesCore({
@@ -148,404 +128,5 @@ async function generateExternalClientTypesCore(service, schema, documents, virtu
 		virtualTypesPath
 	});
 }
-/**
-* Convert first character to uppercase (PascalCase)
-*/
-function toPascalCase(str) {
-	return str.charAt(0).toUpperCase() + str.slice(1);
-}
-/**
-* Extract subscription operations from GraphQL documents
-*/
-function extractSubscriptions(docs) {
-	const subscriptions = [];
-	for (const doc of docs) {
-		if (!doc.document) continue;
-		for (const def of doc.document.definitions) if (def.kind === Kind.OPERATION_DEFINITION && def.operation === "subscription") {
-			const operationDef = def;
-			const name = operationDef.name?.value;
-			if (!name) continue;
-			const firstSelection = operationDef.selectionSet.selections[0];
-			if (firstSelection.kind !== Kind.FIELD) continue;
-			const fieldName = firstSelection.name.value;
-			const hasVariables = (operationDef.variableDefinitions?.length || 0) > 0;
-			subscriptions.push({
-				name,
-				typeName: toPascalCase(name),
-				fieldName,
-				hasVariables
-			});
-		}
-	}
-	return subscriptions;
-}
-/**
-* Generate subscription builder code (Drizzle-style API) + Vue Composables
-* Returns empty string if subscriptions are not enabled or no subscription operations found
-*/
-function generateSubscriptionBuilder(docs, subscriptionsEnabled) {
-	if (!subscriptionsEnabled) return "";
-	const subscriptions = extractSubscriptions(docs);
-	if (subscriptions.length === 0) return "";
-	let output = `
-// === Subscription Imports ===
-import { ref, onUnmounted, computed } from 'vue'
-import type { Ref } from 'vue'
-import type {
-  ConnectionState,
-  SubscriptionHandle,
-  SubscriptionSession,
-  SubscriptionTransport,
-  TransportOptions,
-} from 'nitro-graphql/subscribe'
-import { subscriptionClient } from './subscribe'
-
-// === Subscription Types ===
-export type { ConnectionState, SubscriptionHandle, SubscriptionSession, SubscriptionTransport, TransportOptions }
-
-// Forward declaration for UseSubscriptionSessionReturn (defined below)
-export interface UseSubscriptionSessionReturn {
-  /** The underlying session object */
-  session: SubscriptionSession
-  /** Subscribe using the shared session (updates reactive refs) */
-  subscribe: <TData = unknown>(
-    query: string,
-    variables: unknown,
-    onData?: (data: TData) => void,
-    onError?: (error: Error) => void,
-  ) => SubscriptionHandle
-  /** Close all subscriptions and the connection */
-  close: () => void
-  /** Is the session connected (reactive) */
-  isConnected: Ref<boolean>
-  /** Current connection state (reactive) */
-  state: Ref<ConnectionState>
-  /** Number of active subscriptions (reactive) */
-  subscriptionCount: Ref<number>
-}
-
-export interface UseSubscriptionOptions<T> {
-  /** Auto-start subscription on mount (default: false) */
-  immediate?: boolean
-  /** Callback when subscription starts */
-  onStart?: () => void
-  /** Callback when subscription stops */
-  onStop?: () => void
-  /** Callback when data is received */
-  onData?: (data: T) => void
-  /** Callback when error occurs */
-  onError?: (error: Error) => void
-  /** Callback when WebSocket connects */
-  onConnected?: () => void
-  /** Callback when WebSocket reconnects */
-  onReconnected?: () => void
-  /** Callback when WebSocket disconnects */
-  onDisconnected?: () => void
-  /** Callback when connection state changes */
-  onStateChange?: (state: ConnectionState) => void
-  /** Use existing session for multiplexing (pass result from useSubscriptionSession) */
-  session?: UseSubscriptionSessionReturn
-  /** Transport type: 'websocket' (default), 'sse', or 'auto' (WS first, SSE fallback) */
-  transport?: SubscriptionTransport
-}
-
-export interface UseSubscriptionReturn<T> {
-  /** Reactive subscription data */
-  data: Ref<T | null>
-  /** Reactive error state */
-  error: Ref<Error | null>
-  /** Is subscription active */
-  isActive: Ref<boolean>
-  /** Connection state */
-  state: Ref<ConnectionState>
-  /** Active transport type ('websocket' | 'sse') */
-  transport: Ref<'websocket' | 'sse'>
-  /** Start subscription */
-  start: () => void
-  /** Stop subscription */
-  stop: () => void
-  /** Restart subscription */
-  restart: () => void
-}
-
-// === Subscription Builder (Drizzle-style API) ===
-interface SubscriptionBuilder<TData> {
-  onData(fn: (data: TData) => void): SubscriptionBuilder<TData>
-  onError(fn: (error: Error) => void): SubscriptionBuilder<TData>
-  start(): SubscriptionHandle
-  subscribe(fn: (data: TData) => void): SubscriptionHandle
-}
-
-function createSubscriptionBuilder<TData>(query: string, variables: unknown): SubscriptionBuilder<TData> {
-  let onDataFn: ((data: TData) => void) | undefined
-  let onErrorFn: ((error: Error) => void) | undefined
-
-  const builder: SubscriptionBuilder<TData> = {
-    onData(fn: (data: TData) => void) {
-      onDataFn = fn
-      return builder
-    },
-    onError(fn: (error: Error) => void) {
-      onErrorFn = fn
-      return builder
-    },
-    start(): SubscriptionHandle {
-      return subscriptionClient.subscribe(query, variables, onDataFn, onErrorFn)
-    },
-    subscribe(fn: (data: TData) => void): SubscriptionHandle {
-      return subscriptionClient.subscribe(query, variables, fn, undefined)
-    },
-  }
-
-  return builder
-}
-
-export const subscription = {
-`;
-	for (const sub of subscriptions) if (sub.hasVariables) output += `  ${sub.typeName}(variables: Types.${sub.typeName}SubscriptionVariables): SubscriptionBuilder<Types.${sub.typeName}Subscription['${sub.fieldName}']> {
-    return createSubscriptionBuilder<Types.${sub.typeName}Subscription['${sub.fieldName}']>(${sub.typeName}Document, variables)
-  },
-`;
-	else output += `  ${sub.typeName}(): SubscriptionBuilder<Types.${sub.typeName}Subscription['${sub.fieldName}']> {
-    return createSubscriptionBuilder<Types.${sub.typeName}Subscription['${sub.fieldName}']>(${sub.typeName}Document, undefined)
-  },
-`;
-	output += `}
-
-// === Framework-Agnostic Session (for non-Vue usage) ===
-/**
- * Create a multiplexed subscription session (framework-agnostic)
- * All subscriptions share a single WebSocket connection.
- *
- * @example
- * // Vanilla JS / Node.js / React / etc.
- * const session = createSubscriptionSession()
- * const sub1 = session.subscribe(query1, vars1, onData1)
- * const sub2 = session.subscribe(query2, vars2, onData2)
- * // Both use the same WebSocket connection
- * sub1.unsubscribe()
- * session.close() // Close all
- *
- * @returns SubscriptionSession - Framework-agnostic session object
- */
-export function createSubscriptionSession(): SubscriptionSession {
-  return subscriptionClient.createSession()
-}
-
-// === Vue Composable: useSubscriptionSession (Multiplexing) ===
-export interface UseSubscriptionSessionReturn {
-  /** The underlying session object */
-  session: SubscriptionSession
-  /** Subscribe using the shared session */
-  subscribe: <TData = unknown>(
-    query: string,
-    variables: unknown,
-    onData?: (data: TData) => void,
-    onError?: (error: Error) => void,
-  ) => SubscriptionHandle
-  /** Close all subscriptions and the connection */
-  close: () => void
-  /** Is the session connected (reactive) */
-  isConnected: Ref<boolean>
-  /** Current connection state (reactive) */
-  state: Ref<ConnectionState>
-  /** Number of active subscriptions (reactive) */
-  subscriptionCount: Ref<number>
-}
-
-/**
- * Vue composable for multiplexed subscription session
- * Provides reactive state and automatic cleanup on unmount.
- *
- * @example
- * // Vue 3 component
- * const session = useSubscriptionSession()
- * const { data } = useCountdown({ from: 10 }, { session })
- * // Session auto-closes on component unmount
- *
- * @returns UseSubscriptionSessionReturn - Vue-reactive session wrapper
- */
-export function useSubscriptionSession(): UseSubscriptionSessionReturn {
-  const session = subscriptionClient.createSession()
-
-  // Use refs for reactivity (session getters are not reactive)
-  const isConnected = ref(session.isConnected)
-  const state = ref<ConnectionState>(session.state)
-  const subscriptionCount = ref(session.subscriptionCount)
-
-  // Update refs when session state changes
-  function updateRefs() {
-    isConnected.value = session.isConnected
-    state.value = session.state
-    subscriptionCount.value = session.subscriptionCount
-  }
-
-  // Subscribe to session state changes for automatic reactivity
-  const unsubscribeStateChange = session.onStateChange(() => {
-    updateRefs()
-  })
-
-  function subscribe<TData = unknown>(
-    query: string,
-    variables: unknown,
-    onData?: (data: TData) => void,
-    onError?: (error: Error) => void,
-  ): SubscriptionHandle {
-    return session.subscribe(query, variables, onData as (data: unknown) => void, onError)
-  }
-
-  function close() {
-    session.close()
-  }
-
-  onUnmounted(() => {
-    unsubscribeStateChange()
-    close()
-  })
-
-  return {
-    session,
-    subscribe,
-    close,
-    isConnected,
-    state,
-    subscriptionCount,
-  }
-}
-
-// === Vue Composables ===
-function createUseSubscription<TData, TVariables = undefined>(
-  query: string,
-  getVariables: () => TVariables,
-): (options?: UseSubscriptionOptions<TData>) => UseSubscriptionReturn<TData> {
-  return (options: UseSubscriptionOptions<TData> = {}): UseSubscriptionReturn<TData> => {
-    const data = ref<TData | null>(null) as Ref<TData | null>
-    const error = ref<Error | null>(null)
-    const isActive = ref(false)
-    const state = ref<ConnectionState>('idle')
-    const transport = ref<'websocket' | 'sse'>('websocket')
-    let handle: SubscriptionHandle | null = null
-
-    // Resolve transport options
-    const transportOptions: TransportOptions = {
-      transport: options.transport,
-    }
-
-    function start() {
-      stop()
-      isActive.value = true
-      error.value = null
-      options.onStart?.()
-
-      const variables = getVariables()
-
-      if (options.session) {
-        // Use existing session for multiplexing (WebSocket only)
-        handle = options.session.subscribe<TData>(
-          query,
-          variables,
-          (d: TData) => {
-            data.value = d
-            options.onData?.(d)
-          },
-          (e: Error) => {
-            error.value = e
-            options.onError?.(e)
-          },
-        )
-        transport.value = 'websocket'
-      } else {
-        // Create dedicated connection with transport selection
-        handle = subscriptionClient.subscribe<TData>(
-          query,
-          variables,
-          (d: TData) => {
-            data.value = d
-            options.onData?.(d)
-          },
-          (e: Error) => {
-            error.value = e
-            options.onError?.(e)
-          },
-          transportOptions,
-        )
-        // Update transport ref from handle
-        transport.value = handle.transport
-      }
-    }
-
-    function stop() {
-      if (handle) {
-        handle.unsubscribe()
-        handle = null
-        isActive.value = false
-        options.onStop?.()
-      }
-    }
-
-    function restart() {
-      stop()
-      start()
-    }
-
-    if (options.immediate) {
-      start()
-    }
-
-    onUnmounted(stop)
-
-    return { data, error, isActive, state, transport, start, stop, restart }
-  }
-}
-
-// === Subscription Return Types ===
-`;
-	for (const sub of subscriptions) {
-		const typeName = `Types.${sub.typeName}Subscription['${sub.fieldName}']`;
-		output += `/** Return type for use${sub.typeName} composable */
-export type Use${sub.typeName}Return = UseSubscriptionReturn<${typeName}>
-`;
-	}
-	output += `
-// === Vue Composables ===
-`;
-	for (const sub of subscriptions) {
-		const typeName = `Types.${sub.typeName}Subscription['${sub.fieldName}']`;
-		const varsType = `Types.${sub.typeName}SubscriptionVariables`;
-		if (sub.hasVariables) output += `/**
- * Vue composable for ${sub.typeName} subscription
- * @param variables - Subscription variables
- * @param options - Subscription options (immediate, onData, onError, session, etc.)
- * @returns Reactive subscription state: { data, error, isActive, state, start, stop, restart }
- */
-export function use${sub.typeName}(
-  variables: ${varsType},
-  options?: UseSubscriptionOptions<${typeName}>,
-): Use${sub.typeName}Return {
-  return createUseSubscription<${typeName}, ${varsType}>(
-    ${sub.typeName}Document,
-    () => variables,
-  )(options)
-}
-
-`;
-		else output += `/**
- * Vue composable for ${sub.typeName} subscription
- * @param options - Subscription options (immediate, onData, onError, session, etc.)
- * @returns Reactive subscription state: { data, error, isActive, state, start, stop, restart }
- */
-export function use${sub.typeName}(
-  options?: UseSubscriptionOptions<${typeName}>,
-): Use${sub.typeName}Return {
-  return createUseSubscription<${typeName}, undefined>(
-    ${sub.typeName}Document,
-    () => undefined,
-  )(options)
-}
-
-`;
-	}
-	return output;
-}
 //#endregion
-export { DEFAULT_CLIENT_CODEGEN_CONFIG, downloadAndSaveSchema, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateSubscriptionBuilder, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments };
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, generateClientTypesCore, generateExternalClientTypesCore };

package/dist/core/codegen/file-header.d.mts

@@ -0,0 +1,7 @@
+//#region src/core/codegen/file-header.d.ts
+/**
+ * Standard header prepended to all generated files
+ */
+declare const GENERATED_FILE_HEADER = "// THIS FILE IS GENERATED, DO NOT EDIT!\n/* eslint-disable eslint-comments/no-unlimited-disable */\n/* tslint:disable */\n/* eslint-disable */\n/* prettier-ignore */\n";
+//#endregion
+export { GENERATED_FILE_HEADER };

package/dist/core/codegen/file-header.mjs

@@ -0,0 +1,12 @@
+//#region src/core/codegen/file-header.ts
+/**
+* Standard header prepended to all generated files
+*/
+const GENERATED_FILE_HEADER = `// THIS FILE IS GENERATED, DO NOT EDIT!
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+`;
+//#endregion
+export { GENERATED_FILE_HEADER };

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

@@ -1,8 +1,10 @@
+import { DEFAULT_CLIENT_CODEGEN_CONFIG, generateClientTypesCore, generateExternalClientTypesCore } from "./client.mjs";
 import { loadGraphQLDocuments } from "./document-loader.mjs";
+import { GENERATED_FILE_HEADER } from "./file-header.mjs";
+import { generateResolverModule, generateRuntimeIndex, generateSchemaModule } from "./runtime-generator.mjs";
 import { GraphQLLoadSchemaOptions, GraphQLTypeDefPointer, downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
-import { DEFAULT_CLIENT_CODEGEN_CONFIG, SubscriptionInfo, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateSubscriptionBuilder } from "./client.mjs";
-import { GENERATED_FILE_HEADER, pluginContent } from "./plugin.mjs";
-import { generateResolverModule, generateRuntimeIndex, generateSchemaModule } from "./runtime.mjs";
-import { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore, generateTypes } from "./server.mjs";
+import { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore } from "./server.mjs";
+import { SubscriptionInfo, extractSubscriptions } from "./subscription-extractor.mjs";
 import { validateNoDuplicateTypes, validateSchemaFiles } from "./validation.mjs";
-export { DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_SERVER_CODEGEN_CONFIG, GENERATED_FILE_HEADER, type GraphQLLoadSchemaOptions, type GraphQLTypeDefPointer, type SubscriptionInfo, downloadAndSaveSchema, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateSubscriptionBuilder, generateTypes, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments, pluginContent, validateNoDuplicateTypes, validateSchemaFiles };
+import { generateSubscriptionBuilder } from "./vue-subscription-builder.mjs";
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_SERVER_CODEGEN_CONFIG, GENERATED_FILE_HEADER, type GraphQLLoadSchemaOptions, type GraphQLTypeDefPointer, type SubscriptionInfo, downloadAndSaveSchema, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateSubscriptionBuilder, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments, validateNoDuplicateTypes, validateSchemaFiles };

package/dist/core/codegen/index.mjs

@@ -1,8 +1,10 @@
-import { GENERATED_FILE_HEADER, pluginContent } from "./plugin.mjs";
+import { GENERATED_FILE_HEADER } from "./file-header.mjs";
+import { DEFAULT_CLIENT_CODEGEN_CONFIG, generateClientTypesCore, generateExternalClientTypesCore } from "./client.mjs";
 import { loadGraphQLDocuments } from "./document-loader.mjs";
+import { generateResolverModule, generateRuntimeIndex, generateSchemaModule } from "./runtime-generator.mjs";
 import { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
-import { DEFAULT_CLIENT_CODEGEN_CONFIG, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateSubscriptionBuilder } from "./client.mjs";
-import { generateResolverModule, generateRuntimeIndex, generateSchemaModule } from "./runtime.mjs";
-import { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore, generateTypes } from "./server.mjs";
+import { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore } from "./server.mjs";
+import { extractSubscriptions } from "./subscription-extractor.mjs";
 import { validateNoDuplicateTypes, validateSchemaFiles } from "./validation.mjs";
-export { DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_SERVER_CODEGEN_CONFIG, GENERATED_FILE_HEADER, downloadAndSaveSchema, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateSubscriptionBuilder, generateTypes, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments, pluginContent, validateNoDuplicateTypes, validateSchemaFiles };
+import { generateSubscriptionBuilder } from "./vue-subscription-builder.mjs";
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_SERVER_CODEGEN_CONFIG, GENERATED_FILE_HEADER, downloadAndSaveSchema, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateSubscriptionBuilder, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments, validateNoDuplicateTypes, validateSchemaFiles };

package/dist/core/codegen/{runtime.d.mts → runtime-generator.d.mts}

@@ -1,5 +1,5 @@
 import { ScannedResolver } from "../types/scanning.mjs";
-//#region src/core/codegen/runtime.d.ts
+//#region src/core/codegen/runtime-generator.d.ts
 /**
  * Generate resolver module code
  * Outputs Nitro-compatible format with { resolver: ... } wrapper

package/dist/core/codegen/{runtime.mjs → runtime-generator.mjs}

@@ -1,5 +1,5 @@
 import { relative } from "pathe";
-//#region src/core/codegen/runtime.ts
+//#region src/core/codegen/runtime-generator.ts
 const TS_EXTENSION_RE = /\.ts$/;
 const BACKTICK_RE = /`/g;
 const DOLLAR_SIGN_RE = /\$/g;

package/dist/core/codegen/schema-loader.d.mts

@@ -3,16 +3,10 @@ import { GraphQLSchema } from "graphql";
 import { LoadSchemaOptions, UnnormalizedTypeDefPointer } from "@graphql-tools/load";
 
 //#region src/core/codegen/schema-loader.d.ts
-/**
- * Type definition pointer for GraphQL schemas
- */
 type GraphQLTypeDefPointer = UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[];
-/**
- * Options for loading GraphQL schemas
- */
 type GraphQLLoadSchemaOptions = Partial<LoadSchemaOptions>;
 /**
- * Load GraphQL schema synchronously
+ * Load GraphQL schema synchronously from pointers
  */
 declare function graphQLLoadSchemaSync(schemaPointers: GraphQLTypeDefPointer, data?: GraphQLLoadSchemaOptions): GraphQLSchema | undefined;
 /**
@@ -21,6 +15,7 @@ declare function graphQLLoadSchemaSync(schemaPointers: GraphQLTypeDefPointer, da
 declare function loadExternalSchema(service: ExternalServiceCodegenConfig, buildDir?: string): Promise<GraphQLSchema | undefined>;
 /**
  * Download and save schema from external service
+ * Supports modes: true/'once' (download if missing), 'always' (check for updates), 'manual' (skip)
  */
 declare function downloadAndSaveSchema(service: ExternalServiceCodegenConfig, buildDir: string): Promise<string | undefined>;
 //#endregion