nitro-graphql 0.0.4 → 0.0.6

package/dist/utils/index.js

@@ -0,0 +1,107 @@
+import { join, relative } from "pathe";
+import { readFile } from "node:fs/promises";
+import { hash } from "ohash";
+import { parseAsync } from "oxc-parser";
+import { glob } from "tinyglobby";
+
+//#region src/utils/index.ts
+const GLOB_SCAN_PATTERN = "**/*.{graphql,gql,js,mjs,cjs,ts,mts,cts,tsx,jsx}";
+function getImportId(p, lazy) {
+	return (lazy ? "_lazy_" : "_") + hash(p).replace(/-/g, "").slice(0, 6);
+}
+const RELATIVE_RE = /^\.{1,2}\//;
+function relativeWithDot(from, to) {
+	const rel = relative(from, to);
+	return RELATIVE_RE.test(rel) ? rel : `./${rel}`;
+}
+async function scanGraphql(nitro) {
+	const files = await scanFiles(nitro, "graphql");
+	return files.map((f) => f.fullPath);
+}
+async function scanResolvers(nitro) {
+	const files = await scanFiles(nitro, "graphql", "**/*.resolver.{ts,js}");
+	const exportName = [];
+	for (const file of files) {
+		const fileContent = await readFile(file.fullPath, "utf-8");
+		const parsed = await parseAsync(file.fullPath, fileContent);
+		const exports = {
+			imports: [],
+			specifier: file.fullPath
+		};
+		for (const node of parsed.program.body) if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "VariableDeclaration") {
+			for (const decl of node.declaration.declarations) if (decl.type === "VariableDeclarator" && decl.init && decl.id.type === "Identifier") {
+				if (decl.init && decl.init.type === "CallExpression") {
+					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineResolver") exports.imports.push({
+						name: decl.id.name,
+						type: "resolver",
+						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+					});
+					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineQuery") exports.imports.push({
+						name: decl.id.name,
+						type: "query",
+						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+					});
+					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineMutation") exports.imports.push({
+						name: decl.id.name,
+						type: "mutation",
+						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+					});
+					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineType") exports.imports.push({
+						name: decl.id.name,
+						type: "type",
+						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+					});
+					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineSubscription") exports.imports.push({
+						name: decl.id.name,
+						type: "subscription",
+						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+					});
+				}
+			}
+		}
+		if (exports.imports.length > 0) exportName.push(exports);
+	}
+	return exportName;
+}
+async function scanDirectives(nitro) {
+	const files = await scanFiles(nitro, "graphql", "**/*.directive.{ts,js}");
+	return files.map((f) => f.fullPath);
+}
+async function scanTypeDefs(nitro) {
+	const files = await scanFiles(nitro, "graphql", "**/*.typedef.{ts,js}");
+	return files.map((f) => f.fullPath);
+}
+async function scanDefs(nitro) {
+	const files = await scanFiles(nitro, "graphql", "**/*.graphql");
+	return files.map((f) => f.fullPath);
+}
+async function scanFiles(nitro, name, globPattern = GLOB_SCAN_PATTERN) {
+	const files = await Promise.all(nitro.options.scanDirs.map((dir) => scanDir(nitro, dir, name, globPattern))).then((r) => r.flat());
+	return files;
+}
+async function scanDir(nitro, dir, name, globPattern = GLOB_SCAN_PATTERN) {
+	const fileNames = await glob(join(name, globPattern), {
+		cwd: dir,
+		dot: true,
+		ignore: nitro.options.ignore,
+		absolute: true
+	}).catch((error) => {
+		if (error?.code === "ENOTDIR") {
+			nitro.logger.warn(`Ignoring \`${join(dir, name)}\`. It must be a directory.`);
+			return [];
+		}
+		throw error;
+	});
+	return fileNames.map((fullPath) => {
+		return {
+			fullPath,
+			path: relative(join(dir, name), fullPath)
+		};
+	}).sort((a, b) => a.path.localeCompare(b.path));
+}
+function unique(arr) {
+	return [...new Set(arr)];
+}
+
+//#endregion
+export { GLOB_SCAN_PATTERN, getImportId, relativeWithDot, scanDefs, scanDirectives, scanGraphql, scanResolvers, scanTypeDefs, unique };

package/dist/{codegen.js → utils/server-codegen.js}

@@ -1,12 +1,13 @@
+import { defu as defu$1 } from "defu";
+import { parse } from "graphql";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import consola from "consola";
 import { codegen } from "@graphql-codegen/core";
 import * as typescriptPlugin from "@graphql-codegen/typescript";
 import * as typescriptResolversPlugin from "@graphql-codegen/typescript-resolvers";
-import { printSchemaWithDirectives } from "@graphql-tools/utils";
-import { defu } from "defu";
-import { parse } from "graphql";
 import { CurrencyResolver, DateTimeResolver, JSONResolver, NonEmptyStringResolver, UUIDResolver } from "graphql-scalars";
 
-//#region src/codegen.ts
+//#region src/utils/server-codegen.ts
 function pluginContent(_schema, _documents, _config, _info) {
 	return {
 		prepend: [
@@ -44,15 +45,12 @@ async function generateTypes(schema, config = {}, outputPath) {
 		},
 		defaultScalarType: "unknown",
 		defaultMapper: `ResolverReturnType<{T}>`,
-		contextType: "./context#GraphQLContext",
+		contextType: "h3#H3Event",
 		maybeValue: "T | null | undefined",
 		inputMaybeValue: "T | undefined",
-		enumsAsTypes: true,
-		useTypeImports: true,
-		strictScalars: true,
-		emitLegacyCommonJSImports: false
+		declarationKind: "interface"
 	};
-	const mergedConfig = defu(config, defaultConfig);
+	const mergedConfig = defu$1(config, defaultConfig);
 	const output = await codegen({
 		filename: outputPath || "types.generated.ts",
 		schema: parse(printSchemaWithDirectives(schema)),
@@ -66,40 +64,62 @@ async function generateTypes(schema, config = {}, outputPath) {
 		],
 		pluginMap: {
 			pluginContent: { plugin: pluginContent },
-			imports: { plugin: () => ({
-				prepend: [`type Primitive =
-    | null
-    | undefined
-    | string
-    | number
-    | boolean
-    | symbol
-    | bigint;
+			imports: { plugin: () => {
+				return {
+					prepend: [
+						`import schemas from '#graphql/schemas'`,
+						`import type { StandardSchemaV1 } from 'nitro-graphql'`,
+						`
+export type SchemaType = Partial<Record<Partial<keyof ResolversTypes>, StandardSchemaV1>>
+type SchemaKeys = keyof typeof schemas;
+
+type InferInput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferInput<T> : unknown;
+type InferOutput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<T> : unknown;
+
+type InferInputFromSchema<T extends SchemaKeys> = InferInput<(typeof schemas)[T]>;
+type InferOutputFromSchema<T extends SchemaKeys> = InferOutput<(typeof schemas)[T]>;
+
+type Primitive =
+| null
+| undefined
+| string
+| number
+| boolean
+| symbol
+| bigint;
 
 type BuiltIns = Primitive | void | Date | RegExp;
 
+
 type ResolverReturnType<T> = T extends BuiltIns
-    ? T
-    : T extends (...args: any[]) => unknown
-    ? T | undefined
-    : T extends object
-    ? T extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-        ? ItemType[] extends T // Test for arrays (non-tuples) specifically
-            ? Array<ResolverReturnType<ItemType>>
-            : ResolverReturnTypeObject<T> // Tuples behave properly
-        : ResolverReturnTypeObject<T>
-    : unknown;
+? T
+: T extends (...args: any[]) => unknown
+? T | undefined
+: T extends object
+? T extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+  ? ItemType[] extends T // Test for arrays (non-tuples) specifically
+    ? Array<ResolverReturnType<ItemType>>
+    : ResolverReturnTypeObject<T> // Tuples behave properly
+  : ResolverReturnTypeObject<T>
+: unknown;
 
-type ResolverReturnTypeObject<T extends object> = {
-  [K in keyof T]: ResolverReturnType<T[K]>
-};`, ""],
-				content: ""
-			}) },
+type ResolverReturnTypeObject<T extends object> =
+  T extends { __typename?: infer TTypename }
+    ? TTypename extends SchemaKeys
+      ? InferOutputFromSchema<TTypename>
+      : { [K in keyof T]: ResolverReturnType<T[K]> }
+    : { [K in keyof T]: ResolverReturnType<T[K]> };
+`,
+						""
+					],
+					content: ""
+				};
+			} },
 			typescript: typescriptPlugin,
 			typescriptResolvers: typescriptResolversPlugin
 		}
 	}).catch((e) => {
-		console.warn("[nitro-graphql] Code generation error:", e);
+		consola.withTag("graphql").error("Error generating types:", e);
 		return "";
 	});
 	return output;

package/dist/utils/server-type-generation.js

@@ -0,0 +1,52 @@
+import { generateClientTypes, loadGraphQLDocuments } from "./client-codegen.js";
+import { generateTypes } from "./server-codegen.js";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "pathe";
+import { buildASTSchema, buildSchema } from "graphql";
+import { loadFilesSync } from "@graphql-tools/load-files";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import consola from "consola";
+
+//#region src/utils/server-type-generation.ts
+async function serverTypeGeneration(app) {
+	try {
+		const defs = app.scanDefs || [];
+		const loadDefs = loadFilesSync(defs);
+		const mergedDefs = mergeTypeDefs(loadDefs);
+		const schema = buildASTSchema(mergedDefs, {
+			assumeValidSDL: true,
+			assumeValid: true
+		});
+		const data = await generateTypes(schema, app.options.graphql?.codegen?.server ?? {});
+		const printSchema = printSchemaWithDirectives(schema);
+		const schemaPath = resolve(app.graphql.buildDir, "schema.graphql");
+		mkdirSync(dirname(schemaPath), { recursive: true });
+		writeFileSync(schemaPath, printSchema, "utf-8");
+		const serverTypesPath = resolve(app.options.buildDir, "types", "nitro-graphql-server.d.ts");
+		mkdirSync(dirname(serverTypesPath), { recursive: true });
+		writeFileSync(serverTypesPath, data, "utf-8");
+	} catch (error) {
+		consola.error("Server schema generation error:", error);
+	}
+}
+async function clientTypeGeneration(app, path) {
+	try {
+		const root = app.graphql.watchDirs.find((dir) => path.startsWith(dir)) || path;
+		if (!root) return;
+		const docs = await loadGraphQLDocuments(root);
+		const graphqlString = readFileSync(join(app.graphql.buildDir, "schema.graphql"), "utf-8");
+		const schema = buildSchema(graphqlString);
+		const types = await generateClientTypes(schema, docs);
+		if (types === false) return;
+		const clientTypesPath = resolve(app.options.buildDir, "types", "nitro-graphql-client.d.ts");
+		const sdkTypesPath = resolve(app.graphql.clientDir, "sdk.ts");
+		writeFileSync(clientTypesPath, types.types, "utf-8");
+		writeFileSync(sdkTypesPath, types.sdk, "utf-8");
+	} catch (error) {
+		consola.error("Client schema generation error:", error);
+	}
+}
+
+//#endregion
+export { clientTypeGeneration, serverTypeGeneration };

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "nitro-graphql",
   "type": "module",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "GraphQL integration for Nitro",
   "license": "MIT",
   "sideEffects": false,
+  "imports": {
+    "#graphql/server": {
+      "types": "./dist/graphql/server.d.ts",
+      "import": "./dist/graphql/server.js"
+    }
+  },
   "exports": {
     ".": {
-      "types": "./dist/types.d.ts",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
     "./codegen": {
@@ -27,25 +33,36 @@
       "import": "./dist/context.js"
     },
     "./utils": {
-      "types": "./dist/utils.d.ts",
-      "import": "./dist/utils.js"
+      "types": "./dist/utils/index.d.ts",
+      "import": "./dist/utils/index.js"
+    },
+    "./utils/define": {
+      "types": "./dist/utils/define.d.ts",
+      "import": "./dist/utils/define.js"
+    },
+    "./internal": {
+      "types": "./dist/internal/index.d.ts",
+      "import": "./dist/internal/index.js"
     },
-    "./types": {
-      "types": "./dist/types.d.ts",
-      "import": "./dist/types.mjs"
+    "./nuxt": {
+      "types": "./dist/ecosystem/nuxt.d.ts",
+      "import": "./dist/ecosystem/nuxt.js"
     }
   },
   "main": "./dist/index.js",
-  "types": "./dist/types.d.ts",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],
   "peerDependencies": {
+    "graphql": "^16.11.0",
     "nitropack": "^2.11.13"
   },
   "dependencies": {
+    "@apollo/utils.withrequired": "^3.0.0",
+    "@as-integrations/h3": "^2.0.0",
     "@graphql-codegen/core": "^4.0.2",
-    "@graphql-codegen/plugin-helpers": "^5.1.1",
     "@graphql-codegen/typescript": "^4.1.6",
     "@graphql-codegen/typescript-generic-sdk": "^4.0.2",
     "@graphql-codegen/typescript-operations": "^4.6.1",
@@ -59,19 +76,26 @@
     "chokidar": "^4.0.3",
     "consola": "^3.4.2",
     "defu": "^6.1.4",
-    "graphql": "^16.11.0",
     "graphql-scalars": "^1.24.2",
-    "graphql-yoga": "^5.14.0",
+    "knitwork": "^1.2.0",
+    "ohash": "^2.0.11",
+    "oxc-parser": "^0.77.0",
     "pathe": "^2.0.3",
-    "perfect-debounce": "^1.0.0",
     "tinyglobby": "^0.2.14"
   },
   "devDependencies": {
     "@antfu/eslint-config": "^4.16.2",
+    "@apollo/server": "^4.12.2",
+    "@graphql-codegen/import-types-preset": "^3.0.1",
+    "@nuxt/kit": "4.0.0-rc.0",
+    "@nuxt/schema": "4.0.0-rc.0",
     "@types/node": "^20.19.7",
     "bumpp": "^10.2.0",
     "changelogen": "^0.6.2",
-    "eslint": "^9.30.1",
+    "crossws": "0.3.5",
+    "eslint": "^9.31.0",
+    "graphql": "^16.11.0",
+    "graphql-yoga": "^5.15.1",
     "h3": "^1.15.3",
     "nitropack": "^2.11.13",
     "tsdown": "^0.12.9",

package/dist/client-watcher.d.ts

@@ -1,7 +0,0 @@
-import { NitroGraphQLOptions } from "./types.js";
-import { Nitro } from "nitropack/types";
-
-//#region src/client-watcher.d.ts
-declare function setupClientWatcher(nitro: Nitro, options: NitroGraphQLOptions): Promise<void>;
-//#endregion
-export { setupClientWatcher };

package/dist/client-watcher.js

@@ -1,100 +0,0 @@
-import { scanGraphQLFiles } from "./scanner.js";
-import { mkdir, writeFile } from "node:fs/promises";
-import { mergeTypeDefs } from "@graphql-tools/merge";
-import { makeExecutableSchema } from "@graphql-tools/schema";
-import { consola } from "consola";
-import { join } from "pathe";
-import { debounce } from "perfect-debounce";
-
-//#region src/client-watcher.ts
-const logger = consola.withTag("graphql");
-async function regenerateClientTypes(nitro, options) {
-	try {
-		if (!options.client?.enabled) return;
-		const scanResult = await scanGraphQLFiles(nitro);
-		if (scanResult.typeDefs.length === 0) {
-			logger.warn("⚠️  No server schema found for client type generation");
-			return;
-		}
-		const mergedTypeDefs = mergeTypeDefs(scanResult.typeDefs);
-		const schema = makeExecutableSchema({
-			typeDefs: mergedTypeDefs,
-			resolvers: {}
-		});
-		const getClientPatterns = () => {
-			if (options.client?.watchPatterns) return options.client.watchPatterns;
-			const basePatterns = [
-				join(nitro.options.srcDir, "**/*.graphql"),
-				join(nitro.options.srcDir, "**/*.gql"),
-				`!${join(nitro.options.srcDir, "graphql/**/*")}`
-			];
-			if (nitro.options.framework?.name === "nuxt") if (options.client?.nuxtPatterns) basePatterns.unshift(...options.client.nuxtPatterns);
-			else basePatterns.unshift(join(nitro.options.srcDir, "app/graphql/**/*.graphql"), join(nitro.options.srcDir, "app/graphql/**/*.gql"));
-			return basePatterns;
-		};
-		const clientPatterns = getClientPatterns();
-		const { generateClientTypes } = await import("./client-codegen.js");
-		const generatedTypes = await generateClientTypes(schema, clientPatterns, options.client.config, options.client.outputPath);
-		if (generatedTypes) {
-			const outputPath = options.client.outputPath || join(nitro.options.buildDir, "types", "graphql-client.generated.ts");
-			const typesDir = join(nitro.options.buildDir, "types");
-			await mkdir(typesDir, { recursive: true });
-			await writeFile(outputPath, generatedTypes);
-			logger.success("✨ Client types updated");
-		}
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : String(error);
-		logger.error("❌ Client type generation failed:", errorMessage);
-	}
-}
-async function setupClientWatcher(nitro, options) {
-	if (!options.client?.enabled) {
-		logger.info("🚫 Client type generation disabled");
-		return;
-	}
-	const getClientPatterns = () => {
-		if (options.client?.watchPatterns) return options.client.watchPatterns;
-		const basePatterns = [join(nitro.options.srcDir, "**/*.graphql"), join(nitro.options.srcDir, "**/*.gql")];
-		if (nitro.options.framework?.name === "nuxt") if (options.client?.nuxtPatterns) basePatterns.unshift(...options.client.nuxtPatterns);
-		else basePatterns.unshift(join(nitro.options.srcDir, "app/graphql/**/*.graphql"), join(nitro.options.srcDir, "app/graphql/**/*.gql"));
-		return basePatterns;
-	};
-	const clientPatterns = getClientPatterns();
-	const generateClientTypesDebounced = debounce(async () => {
-		await regenerateClientTypes(nitro, options);
-	}, 300);
-	const { watch } = await import("chokidar");
-	const watcher = watch(clientPatterns, {
-		persistent: true,
-		ignoreInitial: true,
-		ignored: [/(^|[/\\])\.\.\./, join(nitro.options.srcDir, "graphql/**/*")],
-		followSymlinks: false,
-		usePolling: true,
-		interval: 500,
-		binaryInterval: 500
-	});
-	watcher.on("add", (path) => {
-		logger.info(`📁 Client file added: ${path}`);
-		generateClientTypesDebounced();
-	});
-	watcher.on("change", (path) => {
-		logger.info(`📝 Client file changed: ${path}`);
-		generateClientTypesDebounced();
-	});
-	watcher.on("unlink", (path) => {
-		logger.info(`🗑️ Client file removed: ${path}`);
-		generateClientTypesDebounced();
-	});
-	watcher.on("error", (error) => {
-		logger.error("❌ Client watcher error:", error);
-	});
-	nitro.hooks.hook("close", () => {
-		logger.info("🔒 Closing client watcher");
-		watcher.close();
-	});
-	await regenerateClientTypes(nitro, options);
-	logger.success("✅ Client watcher ready");
-}
-
-//#endregion
-export { setupClientWatcher };

package/dist/codegen.d.ts

@@ -1,13 +0,0 @@
-import { GraphQLSchema } from "graphql";
-
-//#region src/codegen.d.ts
-interface CodegenServerConfig {
-  contextType?: string;
-  scalars?: Record<string, any>;
-  defaultMapper?: string;
-  mapperTypeSuffix?: string;
-  [key: string]: any;
-}
-declare function generateTypes(schema: GraphQLSchema, config?: CodegenServerConfig, outputPath?: string): Promise<string>;
-//#endregion
-export { CodegenServerConfig, generateTypes };

package/dist/context.d.ts

@@ -1,10 +0,0 @@
-import { YogaInitialContext } from "graphql-yoga";
-import { H3Event } from "h3";
-
-//#region src/context.d.ts
-interface GraphQLContext extends YogaInitialContext {
-  event: H3Event;
-  storage: any;
-}
-//#endregion
-export { GraphQLContext };

package/dist/dev.js

@@ -1,95 +0,0 @@
-import { scanGraphQLFiles } from "./scanner.js";
-import { setupClientWatcher } from "./client-watcher.js";
-import { generateTypes } from "./codegen.js";
-import { mkdir, writeFile } from "node:fs/promises";
-import { mergeTypeDefs } from "@graphql-tools/merge";
-import { makeExecutableSchema } from "@graphql-tools/schema";
-import { consola } from "consola";
-import { join } from "pathe";
-import { debounce } from "perfect-debounce";
-import { existsSync } from "node:fs";
-import { watch } from "chokidar";
-
-//#region src/dev.ts
-const logger = consola.withTag("graphql");
-async function regenerateGraphQLTypes(nitro) {
-	try {
-		const scanResult = await scanGraphQLFiles(nitro);
-		if (scanResult.typeDefs.length === 0) {
-			logger.warn("⚠️  No schema files found");
-			return;
-		}
-		const mergedTypeDefs = mergeTypeDefs(scanResult.typeDefs);
-		const schema = makeExecutableSchema({
-			typeDefs: mergedTypeDefs,
-			resolvers: {}
-		});
-		const generatedTypes = await generateTypes(schema);
-		const outputPath = join(nitro.options.buildDir, "types", "graphql-types.generated.ts");
-		const typesDir = join(nitro.options.buildDir, "types");
-		await mkdir(typesDir, { recursive: true });
-		await writeFile(outputPath, generatedTypes);
-		logger.success("✨ Types regenerated");
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : String(error);
-		logger.error("❌ Type generation failed:", errorMessage);
-	}
-}
-function devmode(nitro, options) {
-	if (nitro.options.dev) {
-		const generateTypesDebounced = debounce(async () => {
-			await regenerateGraphQLTypes(nitro);
-		}, 100);
-		const graphqlDir = join(nitro.options.srcDir, "graphql");
-		logger.info("🔍 Setting up independent GraphQL watcher for directory:", graphqlDir);
-		try {
-			if (!existsSync(graphqlDir)) {
-				logger.warn(`⚠️ GraphQL directory not found: ${graphqlDir}`);
-				return;
-			}
-		} catch (error) {
-			logger.warn("⚠️ Could not check GraphQL directory:", error);
-			return;
-		}
-		const graphqlWatcher = watch(graphqlDir, {
-			ignoreInitial: true,
-			persistent: true,
-			usePolling: true,
-			interval: 500,
-			depth: 10
-		});
-		graphqlWatcher.on("add", (path) => {
-			logger.info("📁 GraphQL file added:", path);
-			generateTypesDebounced();
-		});
-		graphqlWatcher.on("change", (path) => {
-			logger.info("📝 GraphQL file changed:", path);
-			generateTypesDebounced();
-		});
-		graphqlWatcher.on("unlink", (path) => {
-			logger.info("🗑️ GraphQL file deleted:", path);
-			generateTypesDebounced();
-		});
-		graphqlWatcher.on("error", (error) => {
-			logger.error("❌ GraphQL watcher error:", error);
-		});
-		graphqlWatcher.on("raw", (event, path) => {
-			if (event === "change" && path && path.endsWith("graphql")) {
-				logger.info("📝 GraphQL directory change detected, regenerating types");
-				generateTypesDebounced();
-			}
-		});
-		graphqlWatcher.on("ready", () => {
-			logger.success("✅ GraphQL file watcher ready");
-		});
-		nitro.hooks.hook("close", async () => {
-			await graphqlWatcher.close();
-			logger.info("🔒 GraphQL watcher closed");
-		});
-		setupClientWatcher(nitro, options);
-		logger.success("✅ Independent GraphQL watcher set up");
-	}
-}
-
-//#endregion
-export { devmode };