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

package/dist/nitro/virtual/generators.mjs

@@ -0,0 +1,192 @@
+import { resolve } from "pathe";
+import { existsSync, readFileSync } from "node:fs";
+import { genImport } from "knitwork";
+
+//#region src/nitro/virtual/generators.ts
+function generateImportModule(items, exportName, wrapperKey) {
+	if (!items.length) return `export const ${exportName} = []`;
+	const imports = items.flatMap(({ specifier, imports: list, options }) => list?.length ? [genImport(specifier, list, options)] : []);
+	const data = items.flatMap(({ imports: list }) => list.map((i) => `{ ${wrapperKey}: ${i.as || i.name} }`));
+	return `${imports.join("\n")}\n\nexport const ${exportName} = [\n${data.join(",\n")}\n]`;
+}
+function safeGenerateModuleCode(nitro, moduleName) {
+	try {
+		const generator = nitro.options.virtual?.[moduleName];
+		if (generator && typeof generator === "function") return generator();
+		return "// Module not found";
+	} catch (error) {
+		return `// Error: ${error instanceof Error ? error.message : String(error)}`;
+	}
+}
+const serverSchemas = {
+	id: "#nitro-graphql/server-schemas",
+	getCode: (nitro) => {
+		const schemas = [...nitro.scanSchemas, ...nitro.options.graphql?.typedefs ?? []];
+		const directiveSchemas = nitro.graphql.directiveSchemas;
+		if (!schemas.length && !directiveSchemas) {
+			if (nitro.options.dev) nitro.logger.warn(`[nitro-graphql] No schemas found. Using demo schema. Add .graphql files to ${nitro.graphql.serverDir}`);
+			return `export const schemas = [
+  { def: \`type Query {
+  hello: String!
+}
+\` }
+]`;
+		}
+		const schemaArray = schemas.map((schemaPath) => {
+			try {
+				const content = readFileSync(schemaPath, "utf-8");
+				return `{ def: ${JSON.stringify(content)} }`;
+			} catch {
+				return `{ def: '' }`;
+			}
+		});
+		if (directiveSchemas) schemaArray.push(`{ def: ${JSON.stringify(directiveSchemas)} }`);
+		return `export const schemas = [\n${schemaArray.join(",\n")}\n];`;
+	}
+};
+const serverResolvers = {
+	id: "#nitro-graphql/server-resolvers",
+	getCode: (nitro) => {
+		const imports = [...nitro.scanResolvers];
+		if (!imports.length) {
+			if (nitro.options.dev) nitro.logger.warn(`[nitro-graphql] No resolvers found. Using demo resolver. Add .resolver.ts files to ${nitro.graphql.serverDir}`);
+			return `export const resolvers = [
+  { resolver: { Query: { hello: () => 'Hello from nitro-graphql!' } } }
+]`;
+		}
+		return generateImportModule(imports, "resolvers", "resolver");
+	}
+};
+const serverDirectives = {
+	id: "#nitro-graphql/server-directives",
+	getCode: (nitro) => {
+		const imports = nitro.scanDirectives || [];
+		if (!imports.length) return "export const directives = []";
+		return generateImportModule(imports, "directives", "directive");
+	}
+};
+const graphqlConfig = {
+	id: "#nitro-graphql/graphql-config",
+	getCode: (nitro) => {
+		const localConfigPath = resolve(nitro.graphql.serverDir, "config.ts");
+		const extendConfigs = nitro.graphql.extendConfigs || [];
+		const hasLocalConfig = existsSync(localConfigPath);
+		if (!hasLocalConfig && extendConfigs.length === 0) return `const importedConfig = {}
+export { importedConfig }
+`;
+		const imports = ["import { defu } from 'defu'"];
+		const configNames = [];
+		extendConfigs.forEach((configPath, index) => {
+			const configName = `extendConfig${index}`;
+			imports.push(`import ${configName} from '${configPath}'`);
+			configNames.push(configName);
+		});
+		if (hasLocalConfig) {
+			imports.push(`import localConfig from '${localConfigPath}'`);
+			configNames.push("localConfig");
+		}
+		const mergeArgs = configNames.reverse().join(", ");
+		return `${imports.join("\n")}
+
+const importedConfig = defu(${mergeArgs})
+export { importedConfig }
+`;
+	}
+};
+const moduleConfig = {
+	id: "#nitro-graphql/module-config",
+	getCode: (nitro) => {
+		const config = nitro.options.graphql || {};
+		return `export const moduleConfig = ${JSON.stringify(config, null, 2)};`;
+	}
+};
+const validationSchemas = {
+	id: "#nitro-graphql/validation-schemas",
+	getCode: (nitro) => {
+		const localSchemaPath = resolve(nitro.graphql.serverDir, "schema.ts");
+		const extendSchemas = nitro.graphql.extendSchemas || [];
+		const hasLocalSchema = existsSync(localSchemaPath);
+		if (!hasLocalSchema && extendSchemas.length === 0) return `const mergedSchemas = {}
+export default mergedSchemas
+`;
+		const imports = [];
+		const schemaNames = [];
+		extendSchemas.forEach((schemaPath, index) => {
+			const schemaName = `extendSchema${index}`;
+			imports.push(`import ${schemaName} from '${schemaPath}'`);
+			schemaNames.push(schemaName);
+		});
+		if (hasLocalSchema) {
+			imports.push(`import localSchema from '${localSchemaPath}'`);
+			schemaNames.push("localSchema");
+		}
+		const mergeExpression = schemaNames.length === 1 ? schemaNames[0] : `{ ${schemaNames.map((name) => `...${name}`).join(", ")} }`;
+		return `${imports.join("\n")}
+
+const mergedSchemas = ${mergeExpression}
+export default mergedSchemas
+`;
+	}
+};
+const pubsub = {
+	id: "#nitro-graphql/pubsub",
+	getCode: (nitro) => {
+		const subscriptions = nitro.options.graphql?.subscriptions;
+		const pubsubConfig = subscriptions?.pubsub;
+		if (!subscriptions?.enabled) return `export const pubsub = null`;
+		if (pubsubConfig?.customPath) return `import customPubSub from '${pubsubConfig.customPath}'
+export const pubsub = customPubSub
+`;
+		return `import { createPubSub } from 'nitro-graphql/pubsub'
+export const pubsub = createPubSub()
+`;
+	}
+};
+const debugInfo = {
+	id: "#nitro-graphql/debug-info",
+	getCode: (nitro) => {
+		const virtualModuleCodes = {
+			"server-schemas": safeGenerateModuleCode(nitro, "#nitro-graphql/server-schemas"),
+			"server-resolvers": safeGenerateModuleCode(nitro, "#nitro-graphql/server-resolvers"),
+			"server-directives": safeGenerateModuleCode(nitro, "#nitro-graphql/server-directives"),
+			"module-config": safeGenerateModuleCode(nitro, "#nitro-graphql/module-config"),
+			"graphql-config": safeGenerateModuleCode(nitro, "#nitro-graphql/graphql-config"),
+			"pubsub": safeGenerateModuleCode(nitro, "#nitro-graphql/pubsub")
+		};
+		const info = {
+			isDev: nitro.options.dev,
+			framework: nitro.options.framework.name,
+			graphqlFramework: nitro.options.graphql?.framework,
+			federation: nitro.options.graphql?.federation,
+			scanned: {
+				schemas: nitro.scanSchemas?.length || 0,
+				schemaFiles: nitro.scanSchemas || [],
+				resolvers: nitro.scanResolvers?.length || 0,
+				resolverFiles: nitro.scanResolvers || [],
+				directives: nitro.scanDirectives?.length || 0,
+				directiveFiles: nitro.scanDirectives || [],
+				documents: nitro.scanDocuments?.length || 0,
+				documentFiles: nitro.scanDocuments || []
+			},
+			virtualModules: virtualModuleCodes
+		};
+		return `export const debugInfo = ${JSON.stringify(info, null, 2)};`;
+	}
+};
+const allModules = [
+	serverSchemas,
+	serverResolvers,
+	serverDirectives,
+	graphqlConfig,
+	moduleConfig,
+	validationSchemas,
+	pubsub,
+	debugInfo
+];
+function registerAllVirtualModules(nitro) {
+	nitro.options.virtual ??= {};
+	for (const mod of allModules) nitro.options.virtual[mod.id] = () => mod.getCode(nitro);
+}
+
+//#endregion
+export { debugInfo, graphqlConfig, moduleConfig, pubsub, registerAllVirtualModules, serverDirectives, serverResolvers, serverSchemas, validationSchemas };

package/dist/nitro/virtual/stubs.d.mts

@@ -0,0 +1,21 @@
+//#region src/nitro/virtual/stubs.d.ts
+/**
+ * Virtual module stubs for #nitro-graphql/*
+ * Used during build to prevent import resolution errors.
+ * At runtime, Nitro overrides these with actual virtual modules.
+ */
+declare const schemas: Array<{
+  def: string;
+}>;
+declare const resolvers: Array<{
+  resolver: any;
+}>;
+declare const directives: Array<{
+  directive: any;
+}>;
+declare const moduleConfig: {};
+declare const importedConfig: {};
+declare const debugInfo: Record<string, any>;
+declare const pubsub: any;
+//#endregion
+export { debugInfo, directives, importedConfig, moduleConfig, pubsub, resolvers, schemas };

package/dist/nitro/virtual/stubs.mjs

@@ -0,0 +1,32 @@
+//#region src/nitro/virtual/stubs.ts
+/**
+* Virtual module stubs for #nitro-graphql/*
+* Used during build to prevent import resolution errors.
+* At runtime, Nitro overrides these with actual virtual modules.
+*/
+const schemas = [];
+const resolvers = [];
+const directives = [];
+const moduleConfig = {};
+const importedConfig = {};
+const debugInfo = {
+	isDev: false,
+	framework: "",
+	graphqlFramework: "",
+	federation: {},
+	scanned: {
+		schemas: 0,
+		schemaFiles: [],
+		resolvers: 0,
+		resolverFiles: [],
+		directives: 0,
+		directiveFiles: [],
+		documents: 0,
+		documentFiles: []
+	},
+	virtualModules: {}
+};
+const pubsub = null;
+
+//#endregion
+export { debugInfo, directives, importedConfig, moduleConfig, pubsub, resolvers, schemas };

package/dist/{ecosystem/nuxt.d.ts → nuxt.d.mts}

@@ -1,6 +1,6 @@
 import * as _nuxt_schema0 from "@nuxt/schema";
 
-//#region src/ecosystem/nuxt.d.ts
+//#region src/nuxt.d.ts
 interface ModuleOptions {}
 declare const _default: _nuxt_schema0.NuxtModule<ModuleOptions, ModuleOptions, false>;
 //#endregion

package/dist/nuxt.mjs

@@ -0,0 +1,112 @@
+import { getDefaultPaths, getTypesConfig, resolveFilePath } from "./nitro/paths.mjs";
+import { dirname, join, relative, resolve } from "pathe";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { defineNuxtModule, getLayerDirectories } from "@nuxt/kit";
+
+//#region src/nuxt.ts
+var nuxt_default = defineNuxtModule({
+	meta: {
+		name: "nitro-graphql-nuxt",
+		configKey: "nitro-graphql-nuxt",
+		compatibility: { nuxt: ">=3.16.0" }
+	},
+	setup: async (_options, nuxt) => {
+		nuxt.hooks.hook("prepare:types", (options) => {
+			const mockNitro = { options: {
+				rootDir: nuxt.options.rootDir,
+				buildDir: nuxt.options.buildDir,
+				framework: { name: "nuxt" },
+				graphql: nuxt.options.nitro?.graphql
+			} };
+			const placeholders = getDefaultPaths(mockNitro);
+			const typesConfig = getTypesConfig(mockNitro);
+			const tsconfigDir = dirname(join(nuxt.options.buildDir, "tsconfig.json"));
+			const relativeWithDot = (from, to) => {
+				const rel = relative(from, to);
+				return rel.startsWith(".") ? rel : `./${rel}`;
+			};
+			const clientTypesPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
+			if (clientTypesPath) {
+				const relativePath = relativeWithDot(tsconfigDir, clientTypesPath);
+				options.references.push({ path: relativePath });
+				options.tsConfig ??= {};
+				options.tsConfig.compilerOptions ??= {};
+				options.tsConfig.compilerOptions.paths ??= {};
+				options.tsConfig.compilerOptions.paths["#graphql/client"] = [relativePath];
+				options.tsConfig.include = options.tsConfig.include || [];
+				options.tsConfig.include.push(relativePath);
+			}
+			const externalServices = nuxt.options.nitro?.graphql?.externalServices || [];
+			for (const service of externalServices) {
+				const servicePlaceholders = {
+					...placeholders,
+					serviceName: service.name
+				};
+				const externalTypesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", servicePlaceholders);
+				if (externalTypesPath) {
+					const relativePath = relativeWithDot(tsconfigDir, externalTypesPath);
+					options.references.push({ path: relativePath });
+					if (options.tsConfig.compilerOptions) options.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [relativePath];
+					if (options.tsConfig.include) options.tsConfig.include.push(relativePath);
+				}
+			}
+		});
+		nuxt.options.alias = nuxt.options.alias || {};
+		const mockNitro = { options: {
+			rootDir: nuxt.options.rootDir,
+			buildDir: nuxt.options.buildDir,
+			framework: { name: "nuxt" },
+			graphql: nuxt.options.nitro?.graphql
+		} };
+		const placeholders = getDefaultPaths(mockNitro);
+		const typesConfig = getTypesConfig(mockNitro);
+		const clientTypesPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
+		if (clientTypesPath) nuxt.options.alias["#graphql/client"] = clientTypesPath;
+		const externalServices = nuxt.options.nitro?.graphql?.externalServices || [];
+		for (const service of externalServices) {
+			const servicePlaceholders = {
+				...placeholders,
+				serviceName: service.name
+			};
+			const externalTypesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", servicePlaceholders);
+			if (externalTypesPath) nuxt.options.alias[`#graphql/client/${service.name}`] = externalTypesPath;
+		}
+		nuxt.hook("imports:dirs", (dirs) => {
+			const graphqlServerPath = nuxt.options.nitro?.graphql?.serverDir || resolve(nuxt.options.srcDir, "graphql");
+			dirs.push(graphqlServerPath);
+		});
+		nuxt.hook("nitro:config", async (nitroConfig) => {
+			const clientDir = join(nuxt.options.buildDir, "graphql");
+			const layerExtends = (await getLayerDirectories(nuxt)).filter((layer) => layer.root !== `${nuxt.options.rootDir}/`).map((layer) => {
+				const serverDir = layer.server?.replace(/\/$/, "");
+				const appDir = layer.app?.replace(/\/$/, "");
+				if (!serverDir && !appDir) return null;
+				return {
+					serverDir: serverDir ? join(serverDir, "graphql") : void 0,
+					clientDir: appDir ? join(appDir, "graphql") : void 0
+				};
+			}).filter(Boolean);
+			if (!nitroConfig.graphql) nitroConfig.graphql = {};
+			nitroConfig.graphql.extend = [...nitroConfig.graphql?.extend || [], ...layerExtends];
+			if (!existsSync(resolve(nuxt.options.rootDir, "app/graphql"))) {
+				const defaultDir = join(clientDir, "default");
+				if (!existsSync(defaultDir)) mkdirSync(defaultDir, { recursive: true });
+				const sampleQueryFile = join(defaultDir, "queries.graphql");
+				if (!existsSync(sampleQueryFile)) writeFileSync(sampleQueryFile, `# Example GraphQL queries
+# Add your GraphQL queries here
+
+# query GetUser($id: ID!) {
+#   user(id: $id) {
+#     id
+#     name
+#     email
+#   }
+# }
+`, "utf-8");
+			}
+		});
+	}
+});
+
+//#endregion
+export { nuxt_default as default };

package/dist/{graphql/server.d.ts → stubs/index.d.mts}

@@ -1,4 +1,8 @@
-//#region src/graphql/server.d.ts
+//#region src/stubs/index.d.ts
+/**
+ * Runtime type stubs for GraphQL types
+ * These interfaces are replaced by generated types at build time
+ */
 interface StandardSchemaV1 extends Record<string, any> {}
 interface ResolversTypes extends Record<string, any> {}
 interface Resolvers extends Record<string, any> {}

package/dist/stubs/index.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/subscribe/index.d.mts

@@ -0,0 +1,78 @@
+//#region src/subscribe/index.d.ts
+/**
+ * GraphQL Subscription Client
+ * Lightweight wrapper around graphql-ws and graphql-sse
+ *
+ * @example WebSocket (default - uses graphql-ws)
+ * ```typescript
+ * import { createSubscriptionClient } from 'nitro-graphql/subscribe'
+ *
+ * const client = createSubscriptionClient({ wsEndpoint: '/api/graphql/ws' })
+ *
+ * // Simple subscription
+ * const handle = client.subscribe(
+ *   'subscription { countdown(from: 10) }',
+ *   {},
+ *   (data) => console.log(data),
+ *   (error) => console.error(error)
+ * )
+ *
+ * // Unsubscribe
+ * handle.unsubscribe()
+ * ```
+ *
+ * @example SSE Transport (uses graphql-sse)
+ * ```typescript
+ * client.subscribe(query, vars, onData, onError, { transport: 'sse' })
+ * ```
+ *
+ * @example Auto Transport (WebSocket first, SSE fallback)
+ * ```typescript
+ * client.subscribe(query, vars, onData, onError, { transport: 'auto' })
+ * ```
+ *
+ * @module nitro-graphql/subscribe
+ */
+type ConnectionState = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'disconnected' | 'error';
+type SubscriptionTransport = 'websocket' | 'sse' | 'auto';
+interface TransportOptions {
+  /** Transport type: 'websocket' (default), 'sse', or 'auto' (WS first, SSE fallback) */
+  transport?: SubscriptionTransport;
+}
+interface SubscriptionHandle {
+  unsubscribe: () => void;
+  readonly transport: 'websocket' | 'sse';
+}
+interface SubscriptionSession {
+  subscribe: <TData = unknown, TVariables = Record<string, unknown>>(query: string, variables?: TVariables, onData?: (data: TData) => void, onError?: (error: Error) => void) => SubscriptionHandle;
+  readonly isConnected: boolean;
+  readonly state: ConnectionState;
+  readonly subscriptionCount: number;
+  close: () => void;
+  onStateChange: (callback: StateChangeCallback) => () => void;
+}
+type StateChangeCallback = (state: ConnectionState, subscriptionCount: number) => void;
+interface SubscriptionClientConfig {
+  /** WebSocket endpoint (default: '/api/graphql/ws') */
+  wsEndpoint?: string;
+  /** SSE endpoint for SSE transport (default: '/api/graphql') */
+  sseEndpoint?: string;
+  /** Connection parameters for WebSocket handshake */
+  connectionParams?: Record<string, unknown> | (() => Record<string, unknown> | Promise<Record<string, unknown>>);
+  /** Headers for SSE requests */
+  sseHeaders?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+  /** Connection timeout in ms (default: 10000) */
+  connectionTimeoutMs?: number;
+  /** Maximum retry attempts (default: 5) */
+  maxRetries?: number;
+  /** Keep-alive ping interval in ms (default: 25000) */
+  keepAlive?: number;
+}
+interface SubscriptionClient {
+  subscribe: <TData = unknown, TVariables = Record<string, unknown>>(query: string, variables?: TVariables, onData?: (data: TData) => void, onError?: (error: Error) => void, transportOptions?: TransportOptions) => SubscriptionHandle;
+  createSession: () => SubscriptionSession;
+  dispose: () => void;
+}
+declare function createSubscriptionClient(config?: SubscriptionClientConfig): SubscriptionClient;
+//#endregion
+export { ConnectionState, StateChangeCallback, SubscriptionClient, SubscriptionClientConfig, SubscriptionHandle, SubscriptionSession, SubscriptionTransport, TransportOptions, createSubscriptionClient };

package/dist/subscribe/index.mjs

@@ -0,0 +1,206 @@
+import { createClient } from "graphql-sse";
+import { createClient as createClient$1 } from "graphql-ws";
+
+//#region src/subscribe/index.ts
+function toWebSocketUrl(httpUrl) {
+	if (httpUrl.startsWith("/")) return `${typeof window !== "undefined" && window.location.protocol === "https:" ? "wss:" : "ws:"}//${typeof window !== "undefined" ? window.location.host : "localhost"}${httpUrl}`;
+	return httpUrl.replace(/^http/, "ws");
+}
+function toHttpUrl(url) {
+	if (url.startsWith("/")) return `${typeof window !== "undefined" ? window.location.protocol : "http:"}//${typeof window !== "undefined" ? window.location.host : "localhost"}${url}`;
+	return url;
+}
+function extractDataValue(data) {
+	if (!data) return void 0;
+	return Object.values(data)[0];
+}
+function createSseSubscriptionInternal(client, query, variables, onData, onError) {
+	return {
+		unsubscribe: client.subscribe({
+			query,
+			variables
+		}, {
+			next: (result) => {
+				if (result.errors?.length) onError?.(new Error(result.errors[0]?.message || "GraphQL Error"));
+				else if (result.data) {
+					const value = extractDataValue(result.data);
+					if (value !== void 0) onData?.(value);
+				}
+			},
+			error: (err) => {
+				onError?.(err instanceof Error ? err : new Error(String(err)));
+			},
+			complete: () => {}
+		}),
+		transport: "sse"
+	};
+}
+function createWsSubscriptionInternal(client, query, variables, onData, onError) {
+	return {
+		unsubscribe: client.subscribe({
+			query,
+			variables
+		}, {
+			next: (result) => {
+				if (result.errors?.length) onError?.(new Error(result.errors[0]?.message || "GraphQL Error"));
+				else if (result.data) {
+					const value = extractDataValue(result.data);
+					if (value !== void 0) onData?.(value);
+				}
+			},
+			error: (err) => {
+				onError?.(err instanceof Error ? err : new Error(String(err)));
+			},
+			complete: () => {}
+		}),
+		transport: "websocket"
+	};
+}
+function createAutoSubscription(wsClient, sseClient, query, variables, onData, onError, timeoutMs = 5e3) {
+	let activeHandle = null;
+	let fallbackTimeout = null;
+	let wsConnected = false;
+	const wsUnsubscribe = wsClient.subscribe({
+		query,
+		variables
+	}, {
+		next: (result) => {
+			wsConnected = true;
+			if (fallbackTimeout) {
+				clearTimeout(fallbackTimeout);
+				fallbackTimeout = null;
+			}
+			if (result.errors?.length) onError?.(new Error(result.errors[0]?.message || "GraphQL Error"));
+			else if (result.data) {
+				const value = extractDataValue(result.data);
+				if (value !== void 0) onData?.(value);
+			}
+		},
+		error: (err) => {
+			if (!wsConnected) activeHandle = createSseSubscriptionInternal(sseClient, query, variables, onData, onError);
+			else onError?.(err instanceof Error ? err : new Error(String(err)));
+		},
+		complete: () => {}
+	});
+	fallbackTimeout = setTimeout(() => {
+		if (!wsConnected) {
+			wsUnsubscribe();
+			activeHandle = createSseSubscriptionInternal(sseClient, query, variables, onData, onError);
+		}
+	}, timeoutMs);
+	return {
+		unsubscribe: () => {
+			if (fallbackTimeout) clearTimeout(fallbackTimeout);
+			if (activeHandle) activeHandle.unsubscribe();
+			else wsUnsubscribe();
+		},
+		get transport() {
+			return activeHandle?.transport ?? "websocket";
+		}
+	};
+}
+function createSessionInternal(client) {
+	const subscriptions = /* @__PURE__ */ new Map();
+	const stateListeners = /* @__PURE__ */ new Set();
+	let idCounter = 0;
+	let state = "idle";
+	function setState(newState) {
+		state = newState;
+		notifyListeners();
+	}
+	function notifyListeners() {
+		for (const listener of stateListeners) listener(state, subscriptions.size);
+	}
+	setState("connected");
+	return {
+		subscribe(query, variables, onData, onError) {
+			const id = String(++idCounter);
+			const unsubscribe = client.subscribe({
+				query,
+				variables
+			}, {
+				next: (result) => {
+					if (result.errors?.length) onError?.(new Error(result.errors[0]?.message || "GraphQL Error"));
+					else if (result.data) {
+						const value = extractDataValue(result.data);
+						if (value !== void 0) onData?.(value);
+					}
+				},
+				error: (err) => {
+					onError?.(err instanceof Error ? err : new Error(String(err)));
+					subscriptions.delete(id);
+					notifyListeners();
+				},
+				complete: () => {
+					subscriptions.delete(id);
+					notifyListeners();
+				}
+			});
+			subscriptions.set(id, unsubscribe);
+			notifyListeners();
+			return {
+				unsubscribe: () => {
+					unsubscribe();
+					subscriptions.delete(id);
+					notifyListeners();
+				},
+				transport: "websocket"
+			};
+		},
+		get isConnected() {
+			return state === "connected";
+		},
+		get state() {
+			return state;
+		},
+		get subscriptionCount() {
+			return subscriptions.size;
+		},
+		close() {
+			for (const unsubscribe of subscriptions.values()) unsubscribe();
+			subscriptions.clear();
+			setState("disconnected");
+		},
+		onStateChange(callback) {
+			stateListeners.add(callback);
+			return () => stateListeners.delete(callback);
+		}
+	};
+}
+function createSubscriptionClient(config = {}) {
+	const wsEndpoint = config.wsEndpoint ?? "/api/graphql/ws";
+	const sseEndpoint = config.sseEndpoint ?? "/api/graphql";
+	const connectionTimeoutMs = config.connectionTimeoutMs ?? 1e4;
+	const maxRetries = config.maxRetries ?? 5;
+	const keepAlive = config.keepAlive ?? 25e3;
+	const wsClient = createClient$1({
+		url: toWebSocketUrl(wsEndpoint),
+		retryAttempts: maxRetries,
+		keepAlive,
+		connectionAckWaitTimeout: connectionTimeoutMs,
+		connectionParams: config.connectionParams
+	});
+	const sseClient = createClient({
+		url: toHttpUrl(sseEndpoint),
+		retryAttempts: maxRetries,
+		headers: config.sseHeaders
+	});
+	return {
+		subscribe(query, variables, onData, onError, transportOptions) {
+			const transport = transportOptions?.transport ?? "websocket";
+			if (transport === "sse") return createSseSubscriptionInternal(sseClient, query, variables, onData, onError);
+			if (transport === "auto") return createAutoSubscription(wsClient, sseClient, query, variables, onData, onError, connectionTimeoutMs);
+			return createWsSubscriptionInternal(wsClient, query, variables, onData, onError);
+		},
+		createSession() {
+			return createSessionInternal(wsClient);
+		},
+		dispose() {
+			wsClient.dispose();
+			sseClient.dispose();
+		}
+	};
+}
+
+//#endregion
+export { createSubscriptionClient };

package/native/index.d.ts

@@ -0,0 +1,20 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+/**
+ * Validate GraphQL schema files
+ * Returns validation result with errors if any
+ */
+export declare function validateSchemas(filePaths: Array<string>): ValidationResult
+
+/** Validate GraphQL schema from string content (simple version) */
+export declare function validateSchemaString(content: string): ValidationResult
+
+/** Validate GraphQL schema from string content with file paths */
+export declare function validateSchemaStringWithPaths(contents: Array<string>, paths: Array<string>): ValidationResult
+
+/** Validation result from GraphQL schema linting */
+export interface ValidationResult {
+  valid: boolean
+  errors: Array<string>
+  fileCount: number
+}