nitro-graphql 2.0.0-beta.32 → 2.0.0-beta.34

package/dist/utils/schema-builder.mjs

@@ -0,0 +1,51 @@
+import { loadFederationSupport, warnFederationUnavailable } from "./federation.mjs";
+import { consola as consola$1 } from "consola";
+import { parse } from "graphql";
+import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
+import { makeExecutableSchema } from "@graphql-tools/schema";
+
+//#region src/utils/schema-builder.ts
+/**
+* Create a merged GraphQL schema from schemas, resolvers, and directives
+* Supports Apollo Federation when enabled
+*/
+async function createMergedSchema(options) {
+	const { schemas, resolvers, directives, moduleConfig } = options;
+	try {
+		const typeDefs = mergeTypeDefs([schemas.map((schema$1) => schema$1.def).join("\n\n")], {
+			throwOnConflict: true,
+			commentDescriptions: true,
+			sort: true
+		});
+		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
+		const federationEnabled = moduleConfig.federation?.enabled;
+		let schema;
+		if (federationEnabled) {
+			const buildSubgraph = await loadFederationSupport();
+			if (buildSubgraph) schema = buildSubgraph({
+				typeDefs: typeof typeDefs === "string" ? parse(typeDefs) : typeDefs,
+				resolvers: mergedResolvers
+			});
+			else {
+				warnFederationUnavailable();
+				schema = makeExecutableSchema({
+					typeDefs,
+					resolvers: mergedResolvers
+				});
+			}
+		} else schema = makeExecutableSchema({
+			typeDefs,
+			resolvers: mergedResolvers
+		});
+		if (directives && directives.length > 0) {
+			for (const { directive } of directives) if (directive.transformer) schema = directive.transformer(schema);
+		}
+		return schema;
+	} catch (error) {
+		consola$1.error("Schema merge error:", error);
+		throw error;
+	}
+}
+
+//#endregion
+export { createMergedSchema };

package/dist/utils/server-codegen.mjs

@@ -1,43 +1,17 @@
+import { DEFAULT_GRAPHQL_SCALARS } from "../constants/scalars.mjs";
+import { pluginContent } from "./codegen-plugin.mjs";
 import { defu as defu$1 } from "defu";
 import consola from "consola";
 import { parse } from "graphql";
 import { codegen } from "@graphql-codegen/core";
 import * as typescriptPlugin from "@graphql-codegen/typescript";
 import { printSchemaWithDirectives } from "@graphql-tools/utils";
-import { CurrencyResolver, DateTimeISOResolver, DateTimeResolver, JSONObjectResolver, JSONResolver, NonEmptyStringResolver, UUIDResolver } from "graphql-scalars";
 import * as typescriptResolversPlugin from "@graphql-codegen/typescript-resolvers";
 
 //#region src/utils/server-codegen.ts
-/**
-* Plugin to add prepend comments to generated files
-*/
-function pluginContent(_schema, _documents, _config, _info) {
-	return {
-		prepend: [
-			"// THIS FILE IS GENERATED, DO NOT EDIT!",
-			"/* eslint-disable eslint-comments/no-unlimited-disable */",
-			"/* tslint:disable */",
-			"/* eslint-disable */",
-			"/* prettier-ignore */"
-		],
-		content: ""
-	};
-}
 async function generateTypes(selectFremework, schema, config = {}, outputPath) {
 	const mergedConfig = defu$1({
-		scalars: {
-			DateTime: DateTimeResolver.extensions.codegenScalarType,
-			DateTimeISO: DateTimeISOResolver.extensions.codegenScalarType,
-			UUID: UUIDResolver.extensions.codegenScalarType,
-			JSON: JSONResolver.extensions.codegenScalarType,
-			JSONObject: JSONObjectResolver.extensions.codegenScalarType,
-			NonEmptyString: NonEmptyStringResolver.extensions.codegenScalarType,
-			Currency: CurrencyResolver.extensions.codegenScalarType,
-			File: {
-				input: "File",
-				output: "File"
-			}
-		},
+		scalars: DEFAULT_GRAPHQL_SCALARS,
 		defaultScalarType: "unknown",
 		defaultMapper: `ResolverReturnType<{T}>`,
 		contextType: "nitro/h3#H3Event",

package/dist/utils/type-generation.d.mts

@@ -2,5 +2,5 @@ import { generateMainClientTypes } from "../codegen/client-types.mjs";
 import { generateExternalServicesTypes } from "../codegen/external-types.mjs";
 import { generateServerTypes } from "../codegen/server-types.mjs";
 import { validateNoDuplicateTypes } from "../codegen/validation.mjs";
-import { clientTypeGeneration, serverTypeGeneration } from "../codegen/index.mjs";
-export { clientTypeGeneration, generateExternalServicesTypes, generateMainClientTypes, generateServerTypes, serverTypeGeneration, validateNoDuplicateTypes };
+import { generateClientTypes } from "../codegen/index.mjs";
+export { generateClientTypes, generateExternalServicesTypes, generateMainClientTypes, generateServerTypes, validateNoDuplicateTypes };

package/dist/utils/type-generation.mjs

@@ -2,6 +2,6 @@ import { generateMainClientTypes } from "../codegen/client-types.mjs";
 import { generateExternalServicesTypes } from "../codegen/external-types.mjs";
 import { validateNoDuplicateTypes } from "../codegen/validation.mjs";
 import { generateServerTypes } from "../codegen/server-types.mjs";
-import { clientTypeGeneration, serverTypeGeneration } from "../codegen/index.mjs";
+import { generateClientTypes } from "../codegen/index.mjs";
 
-export { clientTypeGeneration, generateExternalServicesTypes, generateMainClientTypes, generateServerTypes, serverTypeGeneration, validateNoDuplicateTypes };
+export { generateClientTypes, generateExternalServicesTypes, generateMainClientTypes, generateServerTypes, validateNoDuplicateTypes };

package/dist/utils/validation.d.mts

@@ -0,0 +1,11 @@
+//#region src/utils/validation.d.ts
+/**
+ * Validation utilities
+ * Configuration validation helpers
+ */
+/**
+ * Validate external GraphQL service configuration
+ */
+declare function validateExternalServices(services: unknown[]): string[];
+//#endregion
+export { validateExternalServices };

package/dist/utils/validation.mjs

@@ -0,0 +1,34 @@
+//#region src/utils/validation.ts
+/**
+* Validation utilities
+* Configuration validation helpers
+*/
+/**
+* Validate external GraphQL service configuration
+*/
+function validateExternalServices(services) {
+	const errors = [];
+	const serviceNames = /* @__PURE__ */ new Set();
+	for (const [index, service] of services.entries()) {
+		const prefix = `externalServices[${index}]`;
+		if (!service || typeof service !== "object") {
+			errors.push(`${prefix} must be an object`);
+			continue;
+		}
+		if (!("name" in service) || typeof service.name !== "string") errors.push(`${prefix}.name is required and must be a string`);
+		else if (serviceNames.has(service.name)) errors.push(`${prefix}.name "${service.name}" must be unique`);
+		else serviceNames.add(service.name);
+		if (!("schema" in service) || !service.schema) errors.push(`${prefix}.schema is required`);
+		if (!("endpoint" in service) || typeof service.endpoint !== "string") errors.push(`${prefix}.endpoint is required and must be a string`);
+		else try {
+			new URL(service.endpoint);
+		} catch {
+			errors.push(`${prefix}.endpoint "${service.endpoint}" must be a valid URL`);
+		}
+		if ("name" in service && service.name && typeof service.name === "string" && !/^[a-z]\w*$/i.test(service.name)) errors.push(`${prefix}.name "${service.name}" must be a valid identifier (letters, numbers, underscore, starting with letter)`);
+	}
+	return errors;
+}
+
+//#endregion
+export { validateExternalServices };

package/dist/virtual/generators/config.d.mts

@@ -0,0 +1,22 @@
+import { Nitro } from "nitro/types";
+
+//#region src/virtual/generators/config.d.ts
+
+/**
+ * Generate virtual module code for GraphQL config (from server/graphql/config.ts)
+ */
+declare function generateGraphQLConfigModule(nitro: Nitro): string;
+/**
+ * Register the GraphQL config virtual module with Nitro
+ */
+declare function virtualGraphQLConfig(nitro: Nitro): void;
+/**
+ * Generate virtual module code for module config (serialized graphql options)
+ */
+declare function generateModuleConfigModule(nitro: Nitro): string;
+/**
+ * Register the module config virtual module with Nitro
+ */
+declare function virtualModuleConfig(nitro: Nitro): void;
+//#endregion
+export { generateGraphQLConfigModule, generateModuleConfigModule, virtualGraphQLConfig, virtualModuleConfig };

package/dist/virtual/generators/config.mjs

@@ -0,0 +1,36 @@
+import { resolve } from "pathe";
+
+//#region src/virtual/generators/config.ts
+/**
+* Generate virtual module code for GraphQL config (from server/graphql/config.ts)
+*/
+function generateGraphQLConfigModule(nitro) {
+	return `import config from '${resolve(nitro.graphql.serverDir, "config.ts")}'
+const importedConfig = config
+export { importedConfig }
+`;
+}
+/**
+* Register the GraphQL config virtual module with Nitro
+*/
+function virtualGraphQLConfig(nitro) {
+	nitro.options.virtual ??= {};
+	nitro.options.virtual["#nitro-graphql/graphql-config"] = () => generateGraphQLConfigModule(nitro);
+}
+/**
+* Generate virtual module code for module config (serialized graphql options)
+*/
+function generateModuleConfigModule(nitro) {
+	const moduleConfig = nitro.options.graphql || {};
+	return `export const moduleConfig = ${JSON.stringify(moduleConfig, null, 2)};`;
+}
+/**
+* Register the module config virtual module with Nitro
+*/
+function virtualModuleConfig(nitro) {
+	nitro.options.virtual ??= {};
+	nitro.options.virtual["#nitro-graphql/module-config"] = () => generateModuleConfigModule(nitro);
+}
+
+//#endregion
+export { generateGraphQLConfigModule, generateModuleConfigModule, virtualGraphQLConfig, virtualModuleConfig };

package/dist/virtual/generators/debug.d.mts

@@ -0,0 +1,14 @@
+import { Nitro } from "nitro/types";
+
+//#region src/virtual/generators/debug.d.ts
+
+/**
+ * Generate virtual module code for debug info
+ */
+declare function generateDebugInfoModule(nitro: Nitro): string;
+/**
+ * Register the debug info virtual module with Nitro
+ */
+declare function virtualDebugInfo(nitro: Nitro): void;
+//#endregion
+export { generateDebugInfoModule, virtualDebugInfo };

package/dist/virtual/generators/debug.mjs

@@ -0,0 +1,53 @@
+//#region src/virtual/generators/debug.ts
+/**
+* Safely call a virtual module generator and capture its output
+*/
+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 generating: ${error instanceof Error ? error.message : String(error)}`;
+	}
+}
+/**
+* Generate virtual module code for debug info
+*/
+function generateDebugInfoModule(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 debugInfo = {
+		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(debugInfo, null, 2)};`;
+}
+/**
+* Register the debug info virtual module with Nitro
+*/
+function virtualDebugInfo(nitro) {
+	nitro.options.virtual ??= {};
+	nitro.options.virtual["#nitro-graphql/debug-info"] = () => generateDebugInfoModule(nitro);
+}
+
+//#endregion
+export { generateDebugInfoModule, virtualDebugInfo };

package/dist/virtual/generators/directives.d.mts

@@ -0,0 +1,14 @@
+import { Nitro } from "nitro/types";
+
+//#region src/virtual/generators/directives.d.ts
+
+/**
+ * Generate virtual module code for server directives
+ */
+declare function generateDirectivesModule(nitro: Nitro): string;
+/**
+ * Register the directives virtual module with Nitro
+ */
+declare function virtualDirectives(nitro: Nitro): void;
+//#endregion
+export { generateDirectivesModule, virtualDirectives };

package/dist/virtual/generators/directives.mjs

@@ -0,0 +1,52 @@
+import { genImport } from "knitwork";
+
+//#region src/virtual/generators/directives.ts
+/**
+* Generate virtual module code for server directives
+*/
+function generateDirectivesModule(nitro) {
+	try {
+		const imports = nitro.scanDirectives || [];
+		if (imports.length === 0) return "export const directives = []";
+		const importsContent = [];
+		const invalidImports = [];
+		for (const { specifier, imports: importList, options } of imports) try {
+			if (!importList || importList.length === 0) {
+				invalidImports.push(`${specifier}: No exports found`);
+				continue;
+			}
+			const importCode = genImport(specifier, importList, options);
+			importsContent.push(importCode);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			invalidImports.push(`${specifier}: ${message}`);
+			if (nitro.options.dev) nitro.logger.error(`[nitro-graphql] Failed to generate import for directive ${specifier}:`, error);
+		}
+		if (invalidImports.length > 0 && nitro.options.dev) {
+			nitro.logger.warn("[nitro-graphql] Some directive imports could not be generated:");
+			for (const msg of invalidImports) nitro.logger.warn(`  - ${msg}`);
+		}
+		const data = imports.map(({ imports: importList }) => importList.map((i) => `{ directive: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n");
+		return [
+			...importsContent,
+			"",
+			"export const directives = [",
+			data,
+			"]",
+			""
+		].join("\n");
+	} catch (error) {
+		nitro.logger.error("[nitro-graphql] Failed to generate virtual directive module:", error);
+		return "export const directives = []";
+	}
+}
+/**
+* Register the directives virtual module with Nitro
+*/
+function virtualDirectives(nitro) {
+	nitro.options.virtual ??= {};
+	nitro.options.virtual["#nitro-graphql/server-directives"] = () => generateDirectivesModule(nitro);
+}
+
+//#endregion
+export { generateDirectivesModule, virtualDirectives };

package/dist/virtual/generators/index.d.mts

@@ -0,0 +1,6 @@
+import { generateGraphQLConfigModule, generateModuleConfigModule, virtualGraphQLConfig, virtualModuleConfig } from "./config.mjs";
+import { generateDebugInfoModule, virtualDebugInfo } from "./debug.mjs";
+import { generateDirectivesModule, virtualDirectives } from "./directives.mjs";
+import { generateResolversModule, virtualResolvers } from "./resolvers.mjs";
+import { generateSchemasModule, virtualSchemas } from "./schemas.mjs";
+export { generateDebugInfoModule, generateDirectivesModule, generateGraphQLConfigModule, generateModuleConfigModule, generateResolversModule, generateSchemasModule, virtualDebugInfo, virtualDirectives, virtualGraphQLConfig, virtualModuleConfig, virtualResolvers, virtualSchemas };

package/dist/virtual/generators/index.mjs

@@ -0,0 +1,7 @@
+import { generateGraphQLConfigModule, generateModuleConfigModule, virtualGraphQLConfig, virtualModuleConfig } from "./config.mjs";
+import { generateDebugInfoModule, virtualDebugInfo } from "./debug.mjs";
+import { generateDirectivesModule, virtualDirectives } from "./directives.mjs";
+import { generateResolversModule, virtualResolvers } from "./resolvers.mjs";
+import { generateSchemasModule, virtualSchemas } from "./schemas.mjs";
+
+export { generateDebugInfoModule, generateDirectivesModule, generateGraphQLConfigModule, generateModuleConfigModule, generateResolversModule, generateSchemasModule, virtualDebugInfo, virtualDirectives, virtualGraphQLConfig, virtualModuleConfig, virtualResolvers, virtualSchemas };

package/dist/virtual/generators/resolvers.d.mts

@@ -0,0 +1,14 @@
+import { Nitro } from "nitro/types";
+
+//#region src/virtual/generators/resolvers.d.ts
+
+/**
+ * Generate virtual module code for server resolvers
+ */
+declare function generateResolversModule(nitro: Nitro): string;
+/**
+ * Register the resolvers virtual module with Nitro
+ */
+declare function virtualResolvers(nitro: Nitro): void;
+//#endregion
+export { generateResolversModule, virtualResolvers };

package/dist/virtual/generators/resolvers.mjs

@@ -0,0 +1,55 @@
+import { genImport } from "knitwork";
+
+//#region src/virtual/generators/resolvers.ts
+/**
+* Generate virtual module code for server resolvers
+*/
+function generateResolversModule(nitro) {
+	try {
+		const imports = [...nitro.scanResolvers];
+		if (imports.length === 0) {
+			if (nitro.options.dev) nitro.logger.warn("[nitro-graphql] No resolvers found. Virtual module will export empty array.");
+			return "export const resolvers = []";
+		}
+		const importsContent = [];
+		const invalidImports = [];
+		for (const { specifier, imports: importList, options } of imports) try {
+			if (!importList || importList.length === 0) {
+				invalidImports.push(`${specifier}: No exports found`);
+				continue;
+			}
+			const importCode = genImport(specifier, importList, options);
+			importsContent.push(importCode);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			invalidImports.push(`${specifier}: ${message}`);
+			if (nitro.options.dev) nitro.logger.error(`[nitro-graphql] Failed to generate import for ${specifier}:`, error);
+		}
+		if (invalidImports.length > 0 && nitro.options.dev) {
+			nitro.logger.warn("[nitro-graphql] Some resolver imports could not be generated:");
+			for (const msg of invalidImports) nitro.logger.warn(`  - ${msg}`);
+		}
+		const data = imports.map(({ imports: importList }) => importList.map((i) => `{ resolver: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n");
+		return [
+			...importsContent,
+			"",
+			"export const resolvers = [",
+			data,
+			"]",
+			""
+		].join("\n");
+	} catch (error) {
+		nitro.logger.error("[nitro-graphql] Failed to generate virtual resolver module:", error);
+		return "export const resolvers = []";
+	}
+}
+/**
+* Register the resolvers virtual module with Nitro
+*/
+function virtualResolvers(nitro) {
+	nitro.options.virtual ??= {};
+	nitro.options.virtual["#nitro-graphql/server-resolvers"] = () => generateResolversModule(nitro);
+}
+
+//#endregion
+export { generateResolversModule, virtualResolvers };

package/dist/virtual/generators/schemas.d.mts

@@ -0,0 +1,14 @@
+import { Nitro } from "nitro/types";
+
+//#region src/virtual/generators/schemas.d.ts
+
+/**
+ * Generate virtual module code for server schemas
+ */
+declare function generateSchemasModule(nitro: Nitro): string;
+/**
+ * Register the schemas virtual module with Nitro
+ */
+declare function virtualSchemas(nitro: Nitro): void;
+//#endregion
+export { generateSchemasModule, virtualSchemas };

package/dist/virtual/generators/schemas.mjs

@@ -0,0 +1,43 @@
+import { getImportId } from "../../utils/imports.mjs";
+
+//#region src/virtual/generators/schemas.ts
+/**
+* Get all schemas from scanned files and config
+*/
+function getSchemas(nitro) {
+	return [...nitro.scanSchemas, ...nitro.options.graphql?.typedefs ?? []];
+}
+/**
+* Generate virtual module code for server schemas
+*/
+function generateSchemasModule(nitro) {
+	try {
+		const imports = getSchemas(nitro);
+		if (imports.length === 0) {
+			if (nitro.options.dev) nitro.logger.warn("[nitro-graphql] No schemas found. Virtual module will export empty array.");
+			return "export const schemas = []";
+		}
+		const importStatements = imports.map((handler) => `import ${getImportId(handler)} from '${handler}';`);
+		const schemaArray = imports.map((h) => `{ def: ${getImportId(h)} }`);
+		return `
+${importStatements.join("\n")}
+
+export const schemas = [
+${schemaArray.join(",\n")}
+];
+    `;
+	} catch (error) {
+		nitro.logger.error("[nitro-graphql] Failed to generate virtual schema module:", error);
+		return "export const schemas = []";
+	}
+}
+/**
+* Register the schemas virtual module with Nitro
+*/
+function virtualSchemas(nitro) {
+	nitro.options.virtual ??= {};
+	nitro.options.virtual["#nitro-graphql/server-schemas"] = () => generateSchemasModule(nitro);
+}
+
+//#endregion
+export { generateSchemasModule, virtualSchemas };

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "nitro-graphql",
   "type": "module",
-  "version": "2.0.0-beta.32",
+  "version": "2.0.0-beta.34",
   "description": "GraphQL integration for Nitro",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/productdevbook/nitro-graphql"
+  },
   "sideEffects": false,
   "imports": {
     "#graphql/server": {
@@ -84,47 +88,47 @@
     "@apollo/subgraph": "^2.12.1",
     "@graphql-codegen/core": "^5.0.0",
     "@graphql-codegen/import-types-preset": "^3.0.1",
-    "@graphql-codegen/typescript": "^5.0.4",
+    "@graphql-codegen/typescript": "^5.0.6",
     "@graphql-codegen/typescript-generic-sdk": "^4.0.2",
-    "@graphql-codegen/typescript-operations": "^5.0.4",
-    "@graphql-codegen/typescript-resolvers": "^5.1.2",
-    "@graphql-tools/graphql-file-loader": "^8.1.6",
-    "@graphql-tools/load": "^8.1.6",
+    "@graphql-codegen/typescript-operations": "^5.0.6",
+    "@graphql-codegen/typescript-resolvers": "^5.1.4",
+    "@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.5",
-    "@graphql-tools/schema": "^10.0.29",
-    "@graphql-tools/url-loader": "^9.0.4",
-    "@graphql-tools/utils": "^10.10.3",
-    "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",
     "consola": "^3.4.2",
     "defu": "^6.1.4",
     "graphql-config": "^5.1.5",
     "graphql-scalars": "^1.25.0",
     "knitwork": "^1.3.0",
     "ohash": "^2.0.11",
-    "oxc-parser": "^0.98.0",
+    "oxc-parser": "^0.101.0",
     "pathe": "^2.0.3",
     "tinyglobby": "^0.2.15"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^6.2.0",
+    "@antfu/eslint-config": "^6.3.0",
     "@nuxt/kit": "^4.2.1",
     "@nuxt/schema": "^4.2.1",
     "@types/node": "^24.10.1",
     "@vitejs/devtools": "^0.0.0-alpha.16",
-    "@vitest/ui": "^3.0.0",
-    "bumpp": "^10.3.1",
+    "@vitest/ui": "^4.0.15",
+    "bumpp": "^10.3.2",
     "changelogen": "^0.6.2",
     "crossws": "^0.4.1",
     "eslint": "^9.39.1",
     "graphql": "16.12.0",
     "graphql-yoga": "5.16.2",
     "nitro": "npm:nitro-nightly@latest",
-    "tsdown": "^0.16.6",
+    "tsdown": "^0.16.8",
     "typescript": "^5.9.3",
     "vite": "npm:rolldown-vite@latest",
     "vitepress-plugin-llms": "^1.9.3",
-    "vitest": "^3.0.0"
+    "vitest": "^4.0.15"
   },
   "resolutions": {
     "nitro-graphql": "link:."
@@ -133,7 +137,7 @@
     "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",