nitro-graphql 2.0.0-beta.56 → 2.0.0-beta.58

package/README.md

@@ -82,5 +82,5 @@ See the [documentation](https://nitro-graphql.pages.dev) for Nuxt and Vite setup
 [docs-href]: https://nitro-graphql.pages.dev
 [beta-src]: https://img.shields.io/npm/v/nitro-graphql/beta?style=flat&logo=rocket&logoColor=white&label=beta&color=7c3aed&colorA=080f12
 [beta-href]: https://github.com/productdevbook/nitro-graphql/releases
-[coverage-src]: https://img.shields.io/badge/coverage-63%25-green?style=flat&colorA=080f12
+[coverage-src]: https://img.shields.io/badge/coverage-71%25-green?style=flat&colorA=080f12
 [coverage-href]: https://github.com/productdevbook/nitro-graphql/actions/workflows/ci.yml

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

@@ -19,5 +19,25 @@ declare function generateClientTypesCore(input: ClientCodegenInput): Promise<Cli
  * Generate client types for external GraphQL service
  */
 declare function generateExternalClientTypesCore(service: ExternalServiceCodegenConfig, schema: GraphQLSchema, documents: Source[], virtualTypesPath?: string): Promise<ClientCodegenResult | false>;
+/**
+ * Subscription info extracted from GraphQL documents
+ */
+interface SubscriptionInfo {
+  /** Original operation name from GraphQL document (used for method names) */
+  name: string;
+  /** PascalCase version for type references (matches GraphQL codegen output) */
+  typeName: string;
+  fieldName: string;
+  hasVariables: boolean;
+}
+/**
+ * Extract subscription operations from GraphQL documents
+ */
+declare function extractSubscriptions(docs: Source[]): SubscriptionInfo[];
+/**
+ * Generate subscription builder code (Drizzle-style API) + Vue Composables
+ * Returns empty string if subscriptions are not enabled or no subscription operations found
+ */
+declare function generateSubscriptionBuilder(docs: Source[], subscriptionsEnabled: boolean): string;
 //#endregion
-export { DEFAULT_CLIENT_CODEGEN_CONFIG, type GraphQLLoadSchemaOptions, type GraphQLTypeDefPointer, downloadAndSaveSchema, generateClientTypesCore, generateExternalClientTypesCore, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments };
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, type GraphQLLoadSchemaOptions, type GraphQLTypeDefPointer, SubscriptionInfo, downloadAndSaveSchema, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateSubscriptionBuilder, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments };

package/dist/core/codegen/client.mjs

@@ -10,7 +10,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 { parse } from "graphql";
+import { Kind, parse } from "graphql";
 
 //#region src/core/codegen/client.ts
 /**
@@ -145,6 +145,405 @@ 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, generateClientTypesCore, generateExternalClientTypesCore, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments };
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, downloadAndSaveSchema, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateSubscriptionBuilder, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments };

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

@@ -1,8 +1,8 @@
 import { loadGraphQLDocuments } from "./document-loader.mjs";
 import { GraphQLLoadSchemaOptions, GraphQLTypeDefPointer, downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
-import { DEFAULT_CLIENT_CODEGEN_CONFIG, generateClientTypesCore, generateExternalClientTypesCore } from "./client.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 { validateNoDuplicateTypes, validateSchemaFiles } from "./validation.mjs";
-export { DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_SERVER_CODEGEN_CONFIG, GENERATED_FILE_HEADER, type GraphQLLoadSchemaOptions, type GraphQLTypeDefPointer, downloadAndSaveSchema, generateClientTypesCore, generateExternalClientTypesCore, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateTypes, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments, pluginContent, validateNoDuplicateTypes, validateSchemaFiles };
+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 };

package/dist/core/codegen/index.mjs

@@ -1,9 +1,9 @@
 import { GENERATED_FILE_HEADER, pluginContent } from "./plugin.mjs";
 import { loadGraphQLDocuments } from "./document-loader.mjs";
 import { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
-import { DEFAULT_CLIENT_CODEGEN_CONFIG, generateClientTypesCore, generateExternalClientTypesCore } from "./client.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 { validateNoDuplicateTypes, validateSchemaFiles } from "./validation.mjs";
 
-export { DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_SERVER_CODEGEN_CONFIG, GENERATED_FILE_HEADER, downloadAndSaveSchema, generateClientTypesCore, generateExternalClientTypesCore, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateTypes, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments, pluginContent, validateNoDuplicateTypes, validateSchemaFiles };
+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 };

package/dist/core/index.d.mts

@@ -6,7 +6,7 @@ import { ResolverImport, ScanContext, ScanResult, ScannedFile, ScannedResolver }
 import "./types/index.mjs";
 import { loadGraphQLDocuments } from "./codegen/document-loader.mjs";
 import { GraphQLLoadSchemaOptions, GraphQLTypeDefPointer, downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./codegen/schema-loader.mjs";
-import { DEFAULT_CLIENT_CODEGEN_CONFIG, generateClientTypesCore, generateExternalClientTypesCore } from "./codegen/client.mjs";
+import { DEFAULT_CLIENT_CODEGEN_CONFIG, SubscriptionInfo, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateSubscriptionBuilder } from "./codegen/client.mjs";
 import { GENERATED_FILE_HEADER, pluginContent } from "./codegen/plugin.mjs";
 import { generateResolverModule, generateRuntimeIndex, generateSchemaModule } from "./codegen/runtime.mjs";
 import { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore, generateTypes } from "./codegen/server.mjs";
@@ -30,4 +30,4 @@ import { getImportId, relativeWithDot } from "./utils/imports.mjs";
 import { createLogger, createSilentLogger, defaultLogger } from "./utils/logger.mjs";
 import { OfetchTemplateOptions, generateOfetchTemplate } from "./utils/ofetch-templates.mjs";
 import { validateExternalServices } from "./validation/external-services.mjs";
-export { ASTScanConfig, BUILTIN_SCALARS, CHUNK_NAME_RESOLVERS, CHUNK_NAME_SCHEMAS, CHUNK_PATH_GRAPHQL, CHUNK_PATH_UNKNOWN, CODEGEN_EXTERNALS, ClientCodegenConfig, ClientCodegenInput, ClientCodegenResult, CoreClientUtilsConfig, CoreCodegenConfig, CoreConfig, CoreContext, CoreExternalService, CoreFederationConfig, CoreGraphQLOptions, CoreLogger, CorePathsConfig, CoreScaffoldConfig, CoreSdkConfig, CoreSecurityConfig, CoreTypesConfig, CreateCoreConfigOptions, CreateMergedSchemaOptions, DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_CLIENT_TYPES_PATH, DEFAULT_GRAPHQL_SCALARS, DEFAULT_SERVER_CODEGEN_CONFIG, DEFAULT_SERVER_TYPES_PATH, DEFINE_DIRECTIVE, DEFINE_FIELD, DEFINE_FUNCTIONS, DEFINE_GRAPHQL_CONFIG, DEFINE_MUTATION, DEFINE_QUERY, DEFINE_RESOLVER, DEFINE_SCHEMA, DEFINE_SUBSCRIPTION, DIRECTIVE_EXTENSIONS, DIRECTIVE_GLOB_PATTERN, DIR_APP_GRAPHQL, DIR_BUILD_NITRO, DIR_BUILD_NUXT, DIR_CLIENT_GRAPHQL, DIR_EXTERNAL, DIR_ROUTES_GRAPHQL, DIR_SERVER_GRAPHQL, DIR_SERVER_GRAPHQL_WIN, DefineDirectiveConfig, DefineFunction, DirectiveArgument, DirectiveDefinition, DirectiveFileRef, DirectiveParser, DirectiveWrapper, ENDPOINT_DEBUG, ENDPOINT_GRAPHQL, ENDPOINT_HEALTH, ExternalServiceCodegenConfig, FEDERATION_EXTERNALS, FILE_CLIENT_TYPES, FILE_CONFIG_TS, FILE_CONTEXT_DTS, FILE_CONTEXT_TS, FILE_DIRECTIVES_GRAPHQL, FILE_GRAPHQL_CONFIG, FILE_GRAPHQL_DTS, FILE_INDEX_TS, FILE_OFETCH_TS, FILE_SCHEMA_GRAPHQL, FILE_SCHEMA_TS, FILE_SDK_TS, FILE_SERVER_TYPES, FRAMEWORK_NITRO, FRAMEWORK_NUXT, FRAMEWORK_STANDALONE, Flatten, Framework, GENERATED_FILE_HEADER, GLOB_SCAN_PATTERN, GRAPHQL_EXTENSIONS, GRAPHQL_FRAMEWORK_APOLLO, GRAPHQL_FRAMEWORK_YOGA, GRAPHQL_GLOB_PATTERN, GRAPHQL_HTTP_METHODS, GraphQLArgumentType, GraphQLBaseType, GraphQLFramework, GraphQLLoadSchemaOptions, GraphQLScalarType, GraphQLTypeDefPointer, HTTP_STATUS_BAD_REQUEST, HTTP_STATUS_INTERNAL_ERROR, LOG_TAG, MaskErrorOptions, ModuleConfig, OfetchTemplateOptions, PATTERN_CLIENT_EXTERNAL_TYPES, PLACEHOLDER_BUILD_DIR, PLACEHOLDER_CLIENT_DIR, PLACEHOLDER_FRAMEWORK, PLACEHOLDER_ROOT_DIR, PLACEHOLDER_SERVER_DIR, PLACEHOLDER_SERVICE_NAME, PLACEHOLDER_TYPES_DIR, PackageConfig, ParsedDirective, RESOLVER_EXTENSIONS, RESOLVER_GLOB_PATTERN, RESOLVER_TYPE_DIRECTIVE, RESOLVER_TYPE_MUTATION, RESOLVER_TYPE_QUERY, RESOLVER_TYPE_RESOLVER, RESOLVER_TYPE_SUBSCRIPTION, RESOLVER_TYPE_TYPE, ResolvedExtend, ResolvedPackage, ResolverDefinition, ResolverImport, ResolverType, SERVICE_DEFAULT, ScalarType, ScanContext, ScanDocumentsOptions, ScanResult, ScannedFile, ScannedResolver, SchemaDefinition, SchemaLoadOptions, SdkCodegenConfig, ServerCodegenConfig, ServerCodegenInput, ServerCodegenResult, buildGraphQLSchema, createCoreConfig, createCoreContext, createDefaultMaskError, createLogger, createMergedSchema, createScanContext, createSilentLogger, deduplicateFiles, defaultLogger, directiveParser, downloadAndSaveSchema, ensureDir, extractPaths, filterByExtension, generateClientTypesCore, generateDirectiveSchema, generateDirectiveSchemas, generateExternalClientTypesCore, generateOfetchTemplate, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateTypes, getImportId, graphQLLoadSchemaSync, isLocalPath, loadExternalSchema, loadFederationSupport, loadGraphQLDocuments, loadPackageConfig, mergeGraphQLOptions, parse, parseDirectiveCall, parseResolverCall, parseSingleFile, pluginContent, readFileSafe, relativeWithDot, resetFederationCache, resolvePackageFiles, scanDirectivesCore, scanDirectory, scanDocumentsCore, scanGraphqlCore, scanResolversCore, scanSchemasCore, scanWithAST, subscribe, validate, validateExternalServices, validateNoDuplicateTypes, validateSchemaFiles, warnFederationUnavailable, writeFile, writeFileIfChanged };
+export { ASTScanConfig, BUILTIN_SCALARS, CHUNK_NAME_RESOLVERS, CHUNK_NAME_SCHEMAS, CHUNK_PATH_GRAPHQL, CHUNK_PATH_UNKNOWN, CODEGEN_EXTERNALS, ClientCodegenConfig, ClientCodegenInput, ClientCodegenResult, CoreClientUtilsConfig, CoreCodegenConfig, CoreConfig, CoreContext, CoreExternalService, CoreFederationConfig, CoreGraphQLOptions, CoreLogger, CorePathsConfig, CoreScaffoldConfig, CoreSdkConfig, CoreSecurityConfig, CoreTypesConfig, CreateCoreConfigOptions, CreateMergedSchemaOptions, DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_CLIENT_TYPES_PATH, DEFAULT_GRAPHQL_SCALARS, DEFAULT_SERVER_CODEGEN_CONFIG, DEFAULT_SERVER_TYPES_PATH, DEFINE_DIRECTIVE, DEFINE_FIELD, DEFINE_FUNCTIONS, DEFINE_GRAPHQL_CONFIG, DEFINE_MUTATION, DEFINE_QUERY, DEFINE_RESOLVER, DEFINE_SCHEMA, DEFINE_SUBSCRIPTION, DIRECTIVE_EXTENSIONS, DIRECTIVE_GLOB_PATTERN, DIR_APP_GRAPHQL, DIR_BUILD_NITRO, DIR_BUILD_NUXT, DIR_CLIENT_GRAPHQL, DIR_EXTERNAL, DIR_ROUTES_GRAPHQL, DIR_SERVER_GRAPHQL, DIR_SERVER_GRAPHQL_WIN, DefineDirectiveConfig, DefineFunction, DirectiveArgument, DirectiveDefinition, DirectiveFileRef, DirectiveParser, DirectiveWrapper, ENDPOINT_DEBUG, ENDPOINT_GRAPHQL, ENDPOINT_HEALTH, ExternalServiceCodegenConfig, FEDERATION_EXTERNALS, FILE_CLIENT_TYPES, FILE_CONFIG_TS, FILE_CONTEXT_DTS, FILE_CONTEXT_TS, FILE_DIRECTIVES_GRAPHQL, FILE_GRAPHQL_CONFIG, FILE_GRAPHQL_DTS, FILE_INDEX_TS, FILE_OFETCH_TS, FILE_SCHEMA_GRAPHQL, FILE_SCHEMA_TS, FILE_SDK_TS, FILE_SERVER_TYPES, FRAMEWORK_NITRO, FRAMEWORK_NUXT, FRAMEWORK_STANDALONE, Flatten, Framework, GENERATED_FILE_HEADER, GLOB_SCAN_PATTERN, GRAPHQL_EXTENSIONS, GRAPHQL_FRAMEWORK_APOLLO, GRAPHQL_FRAMEWORK_YOGA, GRAPHQL_GLOB_PATTERN, GRAPHQL_HTTP_METHODS, GraphQLArgumentType, GraphQLBaseType, GraphQLFramework, GraphQLLoadSchemaOptions, GraphQLScalarType, GraphQLTypeDefPointer, HTTP_STATUS_BAD_REQUEST, HTTP_STATUS_INTERNAL_ERROR, LOG_TAG, MaskErrorOptions, ModuleConfig, OfetchTemplateOptions, PATTERN_CLIENT_EXTERNAL_TYPES, PLACEHOLDER_BUILD_DIR, PLACEHOLDER_CLIENT_DIR, PLACEHOLDER_FRAMEWORK, PLACEHOLDER_ROOT_DIR, PLACEHOLDER_SERVER_DIR, PLACEHOLDER_SERVICE_NAME, PLACEHOLDER_TYPES_DIR, PackageConfig, ParsedDirective, RESOLVER_EXTENSIONS, RESOLVER_GLOB_PATTERN, RESOLVER_TYPE_DIRECTIVE, RESOLVER_TYPE_MUTATION, RESOLVER_TYPE_QUERY, RESOLVER_TYPE_RESOLVER, RESOLVER_TYPE_SUBSCRIPTION, RESOLVER_TYPE_TYPE, ResolvedExtend, ResolvedPackage, ResolverDefinition, ResolverImport, ResolverType, SERVICE_DEFAULT, ScalarType, ScanContext, ScanDocumentsOptions, ScanResult, ScannedFile, ScannedResolver, SchemaDefinition, SchemaLoadOptions, SdkCodegenConfig, ServerCodegenConfig, ServerCodegenInput, ServerCodegenResult, SubscriptionInfo, buildGraphQLSchema, createCoreConfig, createCoreContext, createDefaultMaskError, createLogger, createMergedSchema, createScanContext, createSilentLogger, deduplicateFiles, defaultLogger, directiveParser, downloadAndSaveSchema, ensureDir, extractPaths, extractSubscriptions, filterByExtension, generateClientTypesCore, generateDirectiveSchema, generateDirectiveSchemas, generateExternalClientTypesCore, generateOfetchTemplate, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateSubscriptionBuilder, generateTypes, getImportId, graphQLLoadSchemaSync, isLocalPath, loadExternalSchema, loadFederationSupport, loadGraphQLDocuments, loadPackageConfig, mergeGraphQLOptions, parse, parseDirectiveCall, parseResolverCall, parseSingleFile, pluginContent, readFileSafe, relativeWithDot, resetFederationCache, resolvePackageFiles, scanDirectivesCore, scanDirectory, scanDocumentsCore, scanGraphqlCore, scanResolversCore, scanSchemasCore, scanWithAST, subscribe, validate, validateExternalServices, validateNoDuplicateTypes, validateSchemaFiles, warnFederationUnavailable, writeFile, writeFileIfChanged };

package/dist/core/index.mjs

@@ -3,7 +3,7 @@ import { GENERATED_FILE_HEADER, pluginContent } from "./codegen/plugin.mjs";
 import { loadGraphQLDocuments } from "./codegen/document-loader.mjs";
 import { ensureDir, readFileSafe, writeFile, writeFileIfChanged } from "./utils/file-io.mjs";
 import { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./codegen/schema-loader.mjs";
-import { DEFAULT_CLIENT_CODEGEN_CONFIG, generateClientTypesCore, generateExternalClientTypesCore } from "./codegen/client.mjs";
+import { DEFAULT_CLIENT_CODEGEN_CONFIG, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateSubscriptionBuilder } from "./codegen/client.mjs";
 import { generateResolverModule, generateRuntimeIndex, generateSchemaModule } from "./codegen/runtime.mjs";
 import { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore, generateTypes } from "./codegen/server.mjs";
 import { validateNoDuplicateTypes, validateSchemaFiles } from "./codegen/validation.mjs";
@@ -24,4 +24,4 @@ import { getImportId, relativeWithDot } from "./utils/imports.mjs";
 import { generateOfetchTemplate } from "./utils/ofetch-templates.mjs";
 import { validateExternalServices } from "./validation/external-services.mjs";
 
-export { BUILTIN_SCALARS, CHUNK_NAME_RESOLVERS, CHUNK_NAME_SCHEMAS, CHUNK_PATH_GRAPHQL, CHUNK_PATH_UNKNOWN, CODEGEN_EXTERNALS, DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_CLIENT_TYPES_PATH, DEFAULT_GRAPHQL_SCALARS, DEFAULT_SERVER_CODEGEN_CONFIG, DEFAULT_SERVER_TYPES_PATH, DEFINE_DIRECTIVE, DEFINE_FIELD, DEFINE_FUNCTIONS, DEFINE_GRAPHQL_CONFIG, DEFINE_MUTATION, DEFINE_QUERY, DEFINE_RESOLVER, DEFINE_SCHEMA, DEFINE_SUBSCRIPTION, DIRECTIVE_EXTENSIONS, DIRECTIVE_GLOB_PATTERN, DIR_APP_GRAPHQL, DIR_BUILD_NITRO, DIR_BUILD_NUXT, DIR_CLIENT_GRAPHQL, DIR_EXTERNAL, DIR_ROUTES_GRAPHQL, DIR_SERVER_GRAPHQL, DIR_SERVER_GRAPHQL_WIN, DirectiveParser, ENDPOINT_DEBUG, ENDPOINT_GRAPHQL, ENDPOINT_HEALTH, FEDERATION_EXTERNALS, FILE_CLIENT_TYPES, FILE_CONFIG_TS, FILE_CONTEXT_DTS, FILE_CONTEXT_TS, FILE_DIRECTIVES_GRAPHQL, FILE_GRAPHQL_CONFIG, FILE_GRAPHQL_DTS, FILE_INDEX_TS, FILE_OFETCH_TS, FILE_SCHEMA_GRAPHQL, FILE_SCHEMA_TS, FILE_SDK_TS, FILE_SERVER_TYPES, FRAMEWORK_NITRO, FRAMEWORK_NUXT, FRAMEWORK_STANDALONE, GENERATED_FILE_HEADER, GLOB_SCAN_PATTERN, GRAPHQL_EXTENSIONS, GRAPHQL_FRAMEWORK_APOLLO, GRAPHQL_FRAMEWORK_YOGA, GRAPHQL_GLOB_PATTERN, GRAPHQL_HTTP_METHODS, HTTP_STATUS_BAD_REQUEST, HTTP_STATUS_INTERNAL_ERROR, LOG_TAG, PATTERN_CLIENT_EXTERNAL_TYPES, PLACEHOLDER_BUILD_DIR, PLACEHOLDER_CLIENT_DIR, PLACEHOLDER_FRAMEWORK, PLACEHOLDER_ROOT_DIR, PLACEHOLDER_SERVER_DIR, PLACEHOLDER_SERVICE_NAME, PLACEHOLDER_TYPES_DIR, RESOLVER_EXTENSIONS, RESOLVER_GLOB_PATTERN, RESOLVER_TYPE_DIRECTIVE, RESOLVER_TYPE_MUTATION, RESOLVER_TYPE_QUERY, RESOLVER_TYPE_RESOLVER, RESOLVER_TYPE_SUBSCRIPTION, RESOLVER_TYPE_TYPE, SERVICE_DEFAULT, buildGraphQLSchema, createCoreConfig, createCoreContext, createDefaultMaskError, createLogger, createMergedSchema, createScanContext, createSilentLogger, deduplicateFiles, defaultLogger, directiveParser, downloadAndSaveSchema, ensureDir, extractPaths, filterByExtension, generateClientTypesCore, generateDirectiveSchema, generateDirectiveSchemas, generateExternalClientTypesCore, generateOfetchTemplate, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateTypes, getImportId, graphQLLoadSchemaSync, isLocalPath, loadExternalSchema, loadFederationSupport, loadGraphQLDocuments, loadPackageConfig, mergeGraphQLOptions, parse, parseDirectiveCall, parseResolverCall, parseSingleFile, pluginContent, readFileSafe, relativeWithDot, resetFederationCache, resolvePackageFiles, scanDirectivesCore, scanDirectory, scanDocumentsCore, scanGraphqlCore, scanResolversCore, scanSchemasCore, scanWithAST, subscribe, validate, validateExternalServices, validateNoDuplicateTypes, validateSchemaFiles, warnFederationUnavailable, writeFile, writeFileIfChanged };
+export { BUILTIN_SCALARS, CHUNK_NAME_RESOLVERS, CHUNK_NAME_SCHEMAS, CHUNK_PATH_GRAPHQL, CHUNK_PATH_UNKNOWN, CODEGEN_EXTERNALS, DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_CLIENT_TYPES_PATH, DEFAULT_GRAPHQL_SCALARS, DEFAULT_SERVER_CODEGEN_CONFIG, DEFAULT_SERVER_TYPES_PATH, DEFINE_DIRECTIVE, DEFINE_FIELD, DEFINE_FUNCTIONS, DEFINE_GRAPHQL_CONFIG, DEFINE_MUTATION, DEFINE_QUERY, DEFINE_RESOLVER, DEFINE_SCHEMA, DEFINE_SUBSCRIPTION, DIRECTIVE_EXTENSIONS, DIRECTIVE_GLOB_PATTERN, DIR_APP_GRAPHQL, DIR_BUILD_NITRO, DIR_BUILD_NUXT, DIR_CLIENT_GRAPHQL, DIR_EXTERNAL, DIR_ROUTES_GRAPHQL, DIR_SERVER_GRAPHQL, DIR_SERVER_GRAPHQL_WIN, DirectiveParser, ENDPOINT_DEBUG, ENDPOINT_GRAPHQL, ENDPOINT_HEALTH, FEDERATION_EXTERNALS, FILE_CLIENT_TYPES, FILE_CONFIG_TS, FILE_CONTEXT_DTS, FILE_CONTEXT_TS, FILE_DIRECTIVES_GRAPHQL, FILE_GRAPHQL_CONFIG, FILE_GRAPHQL_DTS, FILE_INDEX_TS, FILE_OFETCH_TS, FILE_SCHEMA_GRAPHQL, FILE_SCHEMA_TS, FILE_SDK_TS, FILE_SERVER_TYPES, FRAMEWORK_NITRO, FRAMEWORK_NUXT, FRAMEWORK_STANDALONE, GENERATED_FILE_HEADER, GLOB_SCAN_PATTERN, GRAPHQL_EXTENSIONS, GRAPHQL_FRAMEWORK_APOLLO, GRAPHQL_FRAMEWORK_YOGA, GRAPHQL_GLOB_PATTERN, GRAPHQL_HTTP_METHODS, HTTP_STATUS_BAD_REQUEST, HTTP_STATUS_INTERNAL_ERROR, LOG_TAG, PATTERN_CLIENT_EXTERNAL_TYPES, PLACEHOLDER_BUILD_DIR, PLACEHOLDER_CLIENT_DIR, PLACEHOLDER_FRAMEWORK, PLACEHOLDER_ROOT_DIR, PLACEHOLDER_SERVER_DIR, PLACEHOLDER_SERVICE_NAME, PLACEHOLDER_TYPES_DIR, RESOLVER_EXTENSIONS, RESOLVER_GLOB_PATTERN, RESOLVER_TYPE_DIRECTIVE, RESOLVER_TYPE_MUTATION, RESOLVER_TYPE_QUERY, RESOLVER_TYPE_RESOLVER, RESOLVER_TYPE_SUBSCRIPTION, RESOLVER_TYPE_TYPE, SERVICE_DEFAULT, buildGraphQLSchema, createCoreConfig, createCoreContext, createDefaultMaskError, createLogger, createMergedSchema, createScanContext, createSilentLogger, deduplicateFiles, defaultLogger, directiveParser, downloadAndSaveSchema, ensureDir, extractPaths, extractSubscriptions, filterByExtension, generateClientTypesCore, generateDirectiveSchema, generateDirectiveSchemas, generateExternalClientTypesCore, generateOfetchTemplate, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateSubscriptionBuilder, generateTypes, getImportId, graphQLLoadSchemaSync, isLocalPath, loadExternalSchema, loadFederationSupport, loadGraphQLDocuments, loadPackageConfig, mergeGraphQLOptions, parse, parseDirectiveCall, parseResolverCall, parseSingleFile, pluginContent, readFileSafe, relativeWithDot, resetFederationCache, resolvePackageFiles, scanDirectivesCore, scanDirectory, scanDocumentsCore, scanGraphqlCore, scanResolversCore, scanSchemasCore, scanWithAST, subscribe, validate, validateExternalServices, validateNoDuplicateTypes, validateSchemaFiles, warnFederationUnavailable, writeFile, writeFileIfChanged };

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

@@ -1,7 +1,7 @@
 //#region src/core/pubsub/index.d.ts
 /**
  * Built-in PubSub implementation for GraphQL Subscriptions
- * Simple EventTarget-based implementation for single-instance deployments
+ * Simple EventEmitter-based implementation for single-instance deployments
  *
  * For multi-instance deployments, use external PubSub solutions like:
  * - Redis (with ioredis)
@@ -34,7 +34,7 @@ type TypedPubSub<Topics extends Record<string, unknown>> = PubSubEngine<Topics>;
 /**
  * Create a simple in-memory PubSub instance
  *
- * This implementation uses EventTarget for lightweight pub/sub functionality.
+ * This implementation uses EventEmitter for lightweight pub/sub functionality.
  * Suitable for:
  * - Development environments
  * - Single-instance production deployments

package/dist/core/pubsub/index.mjs

@@ -1,8 +1,20 @@
+import { EventEmitter } from "node:events";
+
 //#region src/core/pubsub/index.ts
 /**
+* Built-in PubSub implementation for GraphQL Subscriptions
+* Simple EventEmitter-based implementation for single-instance deployments
+*
+* For multi-instance deployments, use external PubSub solutions like:
+* - Redis (with ioredis)
+* - Kafka
+* - RabbitMQ
+* - Cloud Pub/Sub services
+*/
+/**
 * Create a simple in-memory PubSub instance
 *
-* This implementation uses EventTarget for lightweight pub/sub functionality.
+* This implementation uses EventEmitter for lightweight pub/sub functionality.
 * Suitable for:
 * - Development environments
 * - Single-instance production deployments
@@ -37,11 +49,11 @@
 * ```
 */
 function createPubSub() {
-	const eventTarget = new EventTarget();
+	const emitter = new EventEmitter();
+	emitter.setMaxListeners(0);
 	return {
 		async publish(topic, payload) {
-			const event = new CustomEvent(String(topic), { detail: payload });
-			eventTarget.dispatchEvent(event);
+			emitter.emit(String(topic), payload);
 		},
 		subscribe(topic) {
 			const topicStr = String(topic);
@@ -49,8 +61,7 @@ function createPubSub() {
 				const queue = [];
 				let resolve = null;
 				let done = false;
-				const listener = (event) => {
-					const payload = event.detail;
+				const listener = (payload) => {
 					if (resolve) {
 						resolve({
 							value: payload,
@@ -59,7 +70,7 @@ function createPubSub() {
 						resolve = null;
 					} else queue.push(payload);
 				};
-				eventTarget.addEventListener(topicStr, listener);
+				emitter.on(topicStr, listener);
 				return {
 					next() {
 						if (done) return Promise.resolve({
@@ -76,7 +87,7 @@ function createPubSub() {
 					},
 					return() {
 						done = true;
-						eventTarget.removeEventListener(topicStr, listener);
+						emitter.off(topicStr, listener);
 						return Promise.resolve({
 							value: void 0,
 							done: true
@@ -84,7 +95,7 @@ function createPubSub() {
 					},
 					throw(error) {
 						done = true;
-						eventTarget.removeEventListener(topicStr, listener);
+						emitter.off(topicStr, listener);
 						return Promise.reject(error);
 					}
 				};

package/dist/core/utils/subscribe-templates.d.mts

@@ -0,0 +1,8 @@
+//#region src/core/utils/subscribe-templates.d.ts
+/**
+ * Template for GraphQL subscription client config
+ * Small config file that users can customize (like ofetch.ts pattern)
+ */
+declare const subscribeClientTemplate = "// This file is auto-generated once by nitro-graphql for quick start\n// You can modify this file to customize the subscription client\n// The implementation comes from nitro-graphql/subscribe - you'll get updates automatically!\n//\n// Usage Examples:\n// ---------------\n// Basic subscription:\n//   subscriptionClient.subscribe(query, variables, onData, onError)\n//\n// Multiplexed subscriptions (shared connection):\n//   const session = subscriptionClient.createSession()\n//   session.subscribe(query1, vars1, onData1)\n//   session.subscribe(query2, vars2, onData2)\n//\n// With authentication:\n//   Edit connectionParams below to add auth headers\n\nimport type {\n  ConnectionState,\n  SubscriptionClient,\n  SubscriptionClientConfig,\n  SubscriptionHandle,\n  SubscriptionSession,\n} from 'nitro-graphql/subscribe'\nimport { createSubscriptionClient } from 'nitro-graphql/subscribe'\n\n// Re-export types for convenience\nexport type { ConnectionState, SubscriptionClient, SubscriptionHandle, SubscriptionSession }\n\n// Configure the subscription client\n// Customize these settings according to your needs\nconst config: SubscriptionClientConfig = {\n  // WebSocket endpoint (default: '/api/graphql/ws')\n  wsEndpoint: '/api/graphql/ws',\n\n  // Connection timeout in ms (default: 10000)\n  connectionTimeoutMs: 10000,\n\n  // Max reconnection attempts (default: 5)\n  maxRetries: 5,\n\n  // Authentication params sent with connection_init\n  // Can be a function for dynamic values (e.g., JWT tokens)\n  // connectionParams: () => ({\n  //   authorization: `Bearer ${getToken()}`,\n  // }),\n}\n\n// Export configured client instance\nexport const subscriptionClient = createSubscriptionClient(config)\n";
+//#endregion
+export { subscribeClientTemplate };