nitro-graphql 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/nitro/virtual/generators.mjs

@@ -0,0 +1,193 @@
+import { getImportId } from "../../core/utils/imports.mjs";
+import { isAbsolute, resolve } from "pathe";
+import { genImport } from "knitwork";
+
+//#region src/nitro/virtual/generators.ts
+function normalizeExtendConfig(extend) {
+	if (!extend || !Array.isArray(extend) || extend.length === 0) return null;
+	const resolvers = [];
+	const schemas = [];
+	for (const source of extend) if (typeof source === "string") {
+		resolvers.push(`${source}/resolvers`);
+		schemas.push(`${source}/schema`);
+	} else if (source && typeof source === "object") {
+		const obj = source;
+		if (obj.resolvers) {
+			const r = Array.isArray(obj.resolvers) ? obj.resolvers : [obj.resolvers];
+			resolvers.push(...r);
+		}
+		if (obj.schemas) {
+			const s = Array.isArray(obj.schemas) ? obj.schemas : [obj.schemas];
+			schemas.push(...s);
+		}
+	}
+	if (resolvers.length === 0 && schemas.length === 0) return null;
+	return {
+		resolvers,
+		schemas
+	};
+}
+/**
+* Resolve extend path to absolute path
+* Supports: relative paths, absolute paths, package names
+*/
+function resolveExtendPath(nitro, inputPath) {
+	if (inputPath.startsWith("@") || !inputPath.startsWith(".") && !inputPath.startsWith("/")) return inputPath;
+	if (isAbsolute(inputPath)) return inputPath;
+	return resolve(nitro.options.rootDir, inputPath);
+}
+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 ext = normalizeExtendConfig(nitro.options.graphql?.extend);
+		const skipLocalScan = nitro.options.graphql?.skipLocalScan === true;
+		if (ext && ext.schemas.length > 0) {
+			const schemaPaths = ext.schemas.map((p) => resolveExtendPath(nitro, p));
+			const scannedSchemas = [...nitro.scanSchemas, ...nitro.options.graphql?.typedefs ?? []];
+			if (!skipLocalScan && scannedSchemas.length > 0) {
+				const extImports = schemaPaths.map((p, i) => `import { schemaString as extSchema${i} } from '${p}'`);
+				const scannedImports = scannedSchemas.map((s) => `import ${getImportId(s)} from '${s}';`);
+				const extDefs = schemaPaths.map((_, i) => `{ def: extSchema${i} }`);
+				const scannedDefs = scannedSchemas.map((s) => `{ def: ${getImportId(s)} }`);
+				return `${extImports.join("\n")}
+${scannedImports.join("\n")}
+
+export const schemas = [
+${[...extDefs, ...scannedDefs].join(",\n")}
+]`;
+			}
+			if (schemaPaths.length === 1) return `import { schemaString, typeDefs } from '${schemaPaths[0]}'
+export { schemaString, typeDefs }
+export const schemas = [{ def: schemaString }]`;
+			const imports = schemaPaths.map((p, i) => `import { schemaString as schema${i} } from '${p}'`);
+			const schemaVars = schemaPaths.map((_, i) => `schema${i}`);
+			const mergeCode = `export const schemaString = [${schemaVars.join(", ")}].join('\\n\\n')
+import { parse } from 'graphql'
+export const typeDefs = parse(schemaString)
+export const schemas = [${schemaVars.map((v) => `{ def: ${v} }`).join(", ")}]`;
+			return `${imports.join("\n")}\n\n${mergeCode}`;
+		}
+		const schemas = [...nitro.scanSchemas, ...nitro.options.graphql?.typedefs ?? []];
+		if (!schemas.length) {
+			if (nitro.options.dev) nitro.logger.warn("[nitro-graphql] No schemas found. Virtual module will export empty array.");
+			return "export const schemas = []";
+		}
+		const importStatements = schemas.map((s) => `import ${getImportId(s)} from '${s}';`);
+		const schemaArray = schemas.map((s) => `{ def: ${getImportId(s)} }`);
+		return `${importStatements.join("\n")}\n\nexport const schemas = [\n${schemaArray.join(",\n")}\n];`;
+	}
+};
+const serverResolvers = {
+	id: "#nitro-graphql/server-resolvers",
+	getCode: (nitro) => {
+		const ext = normalizeExtendConfig(nitro.options.graphql?.extend);
+		const skipLocalScan = nitro.options.graphql?.skipLocalScan === true;
+		if (ext && ext.resolvers.length > 0) {
+			const resolverPaths = ext.resolvers.map((p) => resolveExtendPath(nitro, p));
+			const imports$1 = resolverPaths.map((p, i) => `import { resolvers as resolvers${i} } from '${p}'`);
+			if (!skipLocalScan && nitro.scanResolvers.length > 0) {
+				const scannedCode = generateImportModule(nitro.scanResolvers, "scannedResolvers", "resolver");
+				const spreadAll$1 = [...resolverPaths.map((_, i) => `...resolvers${i}`), "...scannedResolvers"];
+				return `${imports$1.join("\n")}
+${scannedCode}
+
+export const resolvers = [${spreadAll$1.join(", ")}]`;
+			}
+			if (resolverPaths.length === 1) return `export { resolvers } from '${resolverPaths[0]}'`;
+			const spreadAll = resolverPaths.map((_, i) => `...resolvers${i}`);
+			return `${imports$1.join("\n")}
+
+export const resolvers = [${spreadAll.join(", ")}]`;
+		}
+		const imports = [...nitro.scanResolvers];
+		if (!imports.length) {
+			if (nitro.options.dev) nitro.logger.warn("[nitro-graphql] No resolvers found. Virtual module will export empty array.");
+			return "export const resolvers = []";
+		}
+		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) => {
+		return `import config from '${resolve(nitro.graphql.serverDir, "config.ts")}'
+const importedConfig = config
+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 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")
+		};
+		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,
+	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, registerAllVirtualModules, serverDirectives, serverResolvers, serverSchemas };

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

@@ -0,0 +1,20 @@
+//#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>;
+//#endregion
+export { debugInfo, directives, importedConfig, moduleConfig, resolvers, schemas };

package/dist/nitro/virtual/stubs.mjs

@@ -0,0 +1,31 @@
+//#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: {}
+};
+
+//#endregion
+export { debugInfo, directives, importedConfig, moduleConfig, 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,109 @@
+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$1 = { options: {
+				rootDir: nuxt.options.rootDir,
+				buildDir: nuxt.options.buildDir,
+				framework: { name: "nuxt" },
+				graphql: nuxt.options.nitro?.graphql
+			} };
+			const placeholders$1 = getDefaultPaths(mockNitro$1);
+			const typesConfig$1 = getTypesConfig(mockNitro$1);
+			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$1 = resolveFilePath(typesConfig$1.client, typesConfig$1.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders$1);
+			if (clientTypesPath$1) {
+				const relativePath = relativeWithDot(tsconfigDir, clientTypesPath$1);
+				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$1 = nuxt.options.nitro?.graphql?.externalServices || [];
+			for (const service of externalServices$1) {
+				const servicePlaceholders = {
+					...placeholders$1,
+					serviceName: service.name
+				};
+				const externalTypesPath = resolveFilePath(service.paths?.types ?? typesConfig$1.external, typesConfig$1.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 layerDirs = await getLayerDirectories(nuxt);
+			const layerDirectories = layerDirs.map((layer) => layer.root.replace(/\/$/, "")).filter((root) => root !== nuxt.options.rootDir);
+			const layerServerDirs = layerDirs.filter((layer) => layer.root !== `${nuxt.options.rootDir}/`).map((layer) => layer.server?.replace(/\/$/, "")).filter(Boolean);
+			const layerAppDirs = layerDirs.filter((layer) => layer.root !== `${nuxt.options.rootDir}/`).map((layer) => layer.app?.replace(/\/$/, "")).filter(Boolean);
+			if (!nitroConfig.graphql) nitroConfig.graphql = {};
+			nitroConfig.graphql.layerDirectories = layerDirectories;
+			nitroConfig.graphql.layerServerDirs = layerServerDirs;
+			nitroConfig.graphql.layerAppDirs = layerAppDirs;
+			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/package.json

@@ -1,127 +1,137 @@
 {
   "name": "nitro-graphql",
   "type": "module",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.40",
   "description": "GraphQL integration for Nitro",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/productdevbook/nitro-graphql"
+  },
   "sideEffects": false,
   "imports": {
     "#graphql/server": {
-      "types": "./dist/graphql/server.d.ts",
-      "import": "./dist/graphql/server.js"
-    }
-  },
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "types": "./dist/stubs/index.d.mts",
+      "import": "./dist/stubs/index.mjs"
     },
-    "./codegen": {
-      "types": "./dist/codegen.d.ts",
-      "import": "./dist/codegen.js"
+    "#nitro-graphql/graphql-config": {
+      "types": "./dist/nitro/virtual/stubs.d.mts",
+      "import": "./dist/nitro/virtual/stubs.mjs"
     },
-    "./watcher": {
-      "types": "./dist/watcher.d.ts",
-      "import": "./dist/watcher.js"
+    "#nitro-graphql/server-schemas": {
+      "types": "./dist/nitro/virtual/stubs.d.mts",
+      "import": "./dist/nitro/virtual/stubs.mjs"
     },
-    "./client-watcher": {
-      "types": "./dist/client-watcher.d.ts",
-      "import": "./dist/client-watcher.js"
+    "#nitro-graphql/server-resolvers": {
+      "types": "./dist/nitro/virtual/stubs.d.mts",
+      "import": "./dist/nitro/virtual/stubs.mjs"
     },
-    "./context": {
-      "types": "./dist/context.d.ts",
-      "import": "./dist/context.js"
+    "#nitro-graphql/server-directives": {
+      "types": "./dist/nitro/virtual/stubs.d.mts",
+      "import": "./dist/nitro/virtual/stubs.mjs"
     },
-    "./utils": {
-      "types": "./dist/utils/index.d.ts",
-      "import": "./dist/utils/index.js"
+    "#nitro-graphql/module-config": {
+      "types": "./dist/nitro/virtual/stubs.d.mts",
+      "import": "./dist/nitro/virtual/stubs.mjs"
     },
-    "./utils/define": {
-      "types": "./dist/utils/define.d.ts",
-      "import": "./dist/utils/define.js"
+    "#nitro-graphql/debug-info": {
+      "types": "./dist/nitro/virtual/stubs.d.mts",
+      "import": "./dist/nitro/virtual/stubs.mjs"
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
     },
-    "./utils/apollo": {
-      "types": "./dist/utils/apollo.d.ts",
-      "import": "./dist/utils/apollo.js"
+    "./core": {
+      "types": "./dist/core/index.d.mts",
+      "import": "./dist/core/index.mjs"
     },
-    "./internal": {
-      "types": "./dist/internal/index.d.ts",
-      "import": "./dist/internal/index.js"
+    "./cli": {
+      "types": "./dist/cli/index.d.mts",
+      "import": "./dist/cli/index.mjs"
     },
-    "./nuxt": {
-      "types": "./dist/ecosystem/nuxt.d.ts",
-      "import": "./dist/ecosystem/nuxt.js"
+    "./define": {
+      "types": "./dist/define.d.mts",
+      "import": "./dist/define.mjs"
+    },
+    "./apollo": {
+      "types": "./dist/nitro/apollo.d.mts",
+      "import": "./dist/nitro/apollo.mjs"
     },
-    "./vite": {
-      "types": "./dist/vite.d.ts",
-      "import": "./dist/vite.js"
+    "./nuxt": {
+      "types": "./dist/nuxt.d.mts",
+      "import": "./dist/nuxt.mjs"
     }
   },
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "bin": {
+    "nitro-graphql": "./dist/cli/index.mjs"
+  },
   "files": [
     "dist"
   ],
   "peerDependencies": {
     "@apollo/server": "^5.0.0",
-    "@apollo/utils.withrequired": "^3.0.0",
-    "@as-integrations/h3": "^2.0.0",
     "graphql": "^16.11.0",
-    "h3": "^2.0.1-rc.2",
     "nitro": "^3.0.1-alpha.0"
   },
   "peerDependenciesMeta": {
     "@apollo/server": {
       "optional": true
-    },
-    "@apollo/utils.withrequired": {
-      "optional": true
-    },
-    "@as-integrations/h3": {
-      "optional": true
     }
   },
   "dependencies": {
-    "@apollo/subgraph": "^2.11.3",
+    "@apollo/subgraph": "^2.12.2",
+    "@bomb.sh/tab": "^0.0.11",
     "@graphql-codegen/core": "^5.0.0",
     "@graphql-codegen/import-types-preset": "^3.0.1",
-    "@graphql-codegen/typescript": "^5.0.2",
+    "@graphql-codegen/typed-document-node": "^6.1.5",
+    "@graphql-codegen/typescript": "^5.0.7",
     "@graphql-codegen/typescript-generic-sdk": "^4.0.2",
-    "@graphql-codegen/typescript-operations": "^5.0.2",
-    "@graphql-codegen/typescript-resolvers": "^5.1.0",
-    "@graphql-tools/graphql-file-loader": "^8.1.2",
-    "@graphql-tools/load": "^8.1.2",
+    "@graphql-codegen/typescript-operations": "^5.0.7",
+    "@graphql-codegen/typescript-resolvers": "^5.1.5",
+    "@graphql-tools/graphql-file-loader": "^8.1.8",
+    "@graphql-tools/load": "^8.1.7",
     "@graphql-tools/load-files": "^7.0.1",
-    "@graphql-tools/merge": "^9.1.1",
-    "@graphql-tools/schema": "^10.0.25",
-    "@graphql-tools/url-loader": "^9.0.0",
-    "@graphql-tools/utils": "^10.9.1",
-    "chokidar": "^4.0.3",
+    "@graphql-tools/merge": "^9.1.6",
+    "@graphql-tools/schema": "^10.0.30",
+    "@graphql-tools/url-loader": "^9.0.5",
+    "@graphql-tools/utils": "^10.11.0",
+    "chokidar": "^5.0.0",
+    "citty": "^0.1.6",
     "consola": "^3.4.2",
     "defu": "^6.1.4",
+    "giget": "^2.0.0",
     "graphql-config": "^5.1.5",
     "graphql-scalars": "^1.25.0",
-    "knitwork": "^1.2.0",
+    "knitwork": "^1.3.0",
     "ohash": "^2.0.11",
-    "oxc-parser": "^0.95.0",
+    "oxc-parser": "^0.106.0",
     "pathe": "^2.0.3",
     "tinyglobby": "^0.2.15"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^6.0.0",
-    "@nuxt/kit": "^4.1.3",
-    "@nuxt/schema": "^4.1.3",
-    "@types/node": "^24.7.2",
-    "bumpp": "^10.3.1",
+    "@antfu/eslint-config": "^6.7.3",
+    "@nuxt/kit": "^4.2.2",
+    "@nuxt/schema": "^4.2.2",
+    "@types/node": "^25.0.3",
+    "@vitejs/devtools": "^0.0.0-alpha.16",
+    "@vitest/ui": "^4.0.16",
+    "bumpp": "^10.3.2",
     "changelogen": "^0.6.2",
-    "crossws": "0.3.5",
-    "eslint": "^9.37.0",
-    "graphql": "16.11.0",
-    "graphql-yoga": "^5.16.0",
-    "h3": "^2.0.1-rc.2",
-    "nitro": "^3.0.1-alpha.0",
-    "tsdown": "^0.15.7",
-    "typescript": "^5.9.3"
+    "crossws": "^0.4.1",
+    "eslint": "^9.39.2",
+    "graphql": "16.12.0",
+    "graphql-yoga": "5.16.2",
+    "nitro": "3.0.1-alpha.1",
+    "tsdown": "^0.18.4",
+    "typescript": "^5.9.3",
+    "vite": "8.0.0-beta.5",
+    "vitepress-plugin-llms": "^1.10.0",
+    "vitest": "^4.0.16"
   },
   "resolutions": {
     "nitro-graphql": "link:."
@@ -130,11 +140,20 @@
     "build": "tsdown",
     "dev": "tsdown --watch",
     "bumpp": "bumpp package.json",
-    "release": "pnpm build && pnpm bumpp && pnpm publish --no-git-checks --access public",
+    "release": "pnpm build && pnpm bumpp",
     "playground:nitro": "cd playgrounds/nitro && pnpm install && pnpm dev",
     "playground:nuxt": "cd playgrounds/nuxt && pnpm install && pnpm dev",
     "playground:federation": "cd playgrounds/federation && pnpm install && pnpm dev",
+    "docs:dev": "cd .docs && pnpm install && pnpm update:metadata && pnpm dev",
+    "docs:build": "cd .docs && pnpm install && pnpm update:metadata && pnpm build",
+    "docs:preview": "cd .docs && pnpm preview",
+    "cli": "node ./dist/cli/index.mjs",
     "lint": "eslint .",
-    "lint:fix": "eslint . --fix"
+    "lint:fix": "eslint . --fix",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:types": "tsc --noEmit"
   }
 }