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

package/dist/core/codegen/schema-loader.d.mts

@@ -3,16 +3,10 @@ import { GraphQLSchema } from "graphql";
 import { LoadSchemaOptions, UnnormalizedTypeDefPointer } from "@graphql-tools/load";
 
 //#region src/core/codegen/schema-loader.d.ts
-/**
- * Type definition pointer for GraphQL schemas
- */
 type GraphQLTypeDefPointer = UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[];
-/**
- * Options for loading GraphQL schemas
- */
 type GraphQLLoadSchemaOptions = Partial<LoadSchemaOptions>;
 /**
- * Load GraphQL schema synchronously
+ * Load GraphQL schema synchronously from pointers
  */
 declare function graphQLLoadSchemaSync(schemaPointers: GraphQLTypeDefPointer, data?: GraphQLLoadSchemaOptions): GraphQLSchema | undefined;
 /**
@@ -21,6 +15,7 @@ declare function graphQLLoadSchemaSync(schemaPointers: GraphQLTypeDefPointer, da
 declare function loadExternalSchema(service: ExternalServiceCodegenConfig, buildDir?: string): Promise<GraphQLSchema | undefined>;
 /**
  * Download and save schema from external service
+ * Supports modes: true/'once' (download if missing), 'always' (check for updates), 'manual' (skip)
  */
 declare function downloadAndSaveSchema(service: ExternalServiceCodegenConfig, buildDir: string): Promise<string | undefined>;
 //#endregion

package/dist/core/codegen/schema-loader.mjs

@@ -6,21 +6,47 @@ import { loadSchemaSync } from "@graphql-tools/load";
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { UrlLoader } from "@graphql-tools/url-loader";
-
 //#region src/core/codegen/schema-loader.ts
-/**
-* Check if a path is a URL
-*/
 function isUrl(path) {
 	return path.startsWith("http://") || path.startsWith("https://");
 }
+/** Resolve schema sources and headers from service config */
+function resolveServiceSources(service) {
+	const headers = typeof service.headers === "function" ? service.headers() : service.headers || {};
+	const schemaSource = service.schema ?? service.endpoint;
+	return {
+		headers,
+		schemas: Array.isArray(schemaSource) ? schemaSource : [schemaSource]
+	};
+}
+/** Build loaders array based on schema source types */
+function buildLoaders(schemas) {
+	const loaders = [];
+	if (schemas.some((s) => !isUrl(s))) loaders.push(new GraphQLFileLoader());
+	if (schemas.some(isUrl)) loaders.push(new UrlLoader());
+	return loaders;
+}
+/** Load schema with auto-detected loaders and optional headers */
+function loadWithLoaders(schemas, headers = {}) {
+	const loaders = buildLoaders(schemas);
+	if (loaders.length === 0) throw new Error("No appropriate loaders found for schema sources");
+	return loadSchemaSync(schemas, {
+		loaders,
+		...Object.keys(headers).length > 0 && { headers }
+	});
+}
+/** Resolve the cache file path for a service schema */
+function resolveSchemaFilePath(service, buildDir) {
+	const defaultPath = resolve(buildDir, "graphql", "schemas", `${service.name}.graphql`);
+	return service.downloadPath ? resolve(service.downloadPath) : defaultPath;
+}
 /**
-* Load GraphQL schema synchronously
+* Load GraphQL schema synchronously from pointers
 */
 function graphQLLoadSchemaSync(schemaPointers, data = {}) {
-	const filteredPointers = [...Array.isArray(schemaPointers) ? schemaPointers : [schemaPointers], "!**/vfs/**"];
+	const pointers = Array.isArray(schemaPointers) ? schemaPointers : [schemaPointers];
 	try {
-		return loadSchemaSync(filteredPointers, {
+		return loadSchemaSync([...pointers, "!**/vfs/**"], {
 			...data,
 			loaders: [
 				new GraphQLFileLoader(),
@@ -29,7 +55,7 @@ function graphQLLoadSchemaSync(schemaPointers, data = {}) {
 			]
 		});
 	} catch (e) {
-		if ((e.message || "").includes("Unable to find any GraphQL type definitions for the following pointers:")) return;
+		if (e.message?.includes("Unable to find any GraphQL type definitions for the following pointers:")) return;
 		throw e;
 	}
 }
@@ -38,91 +64,58 @@ function graphQLLoadSchemaSync(schemaPointers, data = {}) {
 */
 async function loadExternalSchema(service, buildDir) {
 	try {
-		const headers = typeof service.headers === "function" ? service.headers() : service.headers || {};
-		const schemaSource = service.schema ?? service.endpoint;
-		const schemas = Array.isArray(schemaSource) ? schemaSource : [schemaSource];
+		const { headers, schemas } = resolveServiceSources(service);
 		if (service.downloadSchema && buildDir) {
-			const defaultPath = resolve(buildDir, "graphql", "schemas", `${service.name}.graphql`);
-			const schemaFilePath = service.downloadPath ? resolve(service.downloadPath) : defaultPath;
+			const schemaFilePath = resolveSchemaFilePath(service, buildDir);
 			if (existsSync(schemaFilePath)) try {
 				return loadSchemaSync([schemaFilePath], { loaders: [new GraphQLFileLoader()] });
 			} catch {}
 		}
-		const hasUrls = schemas.some((schema) => isUrl(schema));
-		const hasLocalFiles = schemas.some((schema) => !isUrl(schema));
-		const loaders = [];
-		if (hasLocalFiles) loaders.push(new GraphQLFileLoader());
-		if (hasUrls) loaders.push(new UrlLoader());
-		if (loaders.length === 0) throw new Error("No appropriate loaders found for schema sources");
-		return loadSchemaSync(schemas, {
-			loaders,
-			...Object.keys(headers).length > 0 && { headers }
-		});
+		return loadWithLoaders(schemas, headers);
 	} catch {
 		return;
 	}
 }
 /**
 * Download and save schema from external service
+* Supports modes: true/'once' (download if missing), 'always' (check for updates), 'manual' (skip)
 */
 async function downloadAndSaveSchema(service, buildDir) {
 	const downloadMode = service.downloadSchema;
 	if (!downloadMode || downloadMode === "manual") return;
-	const defaultPath = resolve(buildDir, "graphql", "schemas", `${service.name}.graphql`);
-	const schemaFilePath = service.downloadPath ? resolve(service.downloadPath) : defaultPath;
+	const schemaFilePath = resolveSchemaFilePath(service, buildDir);
 	try {
-		const headers = typeof service.headers === "function" ? service.headers() : service.headers || {};
-		const schemaSource = service.schema ?? service.endpoint;
-		const schemas = Array.isArray(schemaSource) ? schemaSource : [schemaSource];
-		const hasUrlSchemas = schemas.some((schema) => isUrl(schema));
-		const hasLocalSchemas = schemas.some((schema) => !isUrl(schema));
-		let shouldDownload = false;
+		const { headers, schemas } = resolveServiceSources(service);
 		const fileExists = existsSync(schemaFilePath);
-		if (downloadMode === "always") {
-			shouldDownload = true;
-			if (fileExists && hasUrlSchemas) try {
-				const remoteSchemaString = printSchemaWithDirectives(loadSchemaSync(schemas.filter(isUrl), {
-					loaders: [new UrlLoader()],
-					...Object.keys(headers).length > 0 && { headers }
-				}));
-				const remoteHash = createHash("md5").update(remoteSchemaString).digest("hex");
-				const localSchemaString = readFileSync(schemaFilePath, "utf-8");
-				if (remoteHash === createHash("md5").update(localSchemaString).digest("hex")) shouldDownload = false;
-			} catch {
-				shouldDownload = true;
-			}
-			else if (fileExists && hasLocalSchemas) {
-				const localFiles = schemas.filter((schema) => !isUrl(schema));
-				let sourceIsNewer = false;
-				for (const localFile of localFiles) if (existsSync(localFile)) {
-					const sourceStats = statSync(localFile);
-					const cachedStats = statSync(schemaFilePath);
-					if (sourceStats.mtime > cachedStats.mtime) {
-						sourceIsNewer = true;
-						break;
-					}
-				}
-				if (!sourceIsNewer) shouldDownload = false;
-			}
-		} else if (downloadMode === true || downloadMode === "once") shouldDownload = !fileExists;
-		if (shouldDownload) {
-			let schema;
-			if (hasUrlSchemas && hasLocalSchemas) schema = loadSchemaSync(schemas, {
-				loaders: [new GraphQLFileLoader(), new UrlLoader()],
-				...Object.keys(headers).length > 0 && { headers }
-			});
-			else if (hasUrlSchemas) schema = loadSchemaSync(schemas, {
-				loaders: [new UrlLoader()],
-				...Object.keys(headers).length > 0 && { headers }
-			});
-			else schema = loadSchemaSync(schemas, { loaders: [new GraphQLFileLoader()] });
-			writeFileIfChanged(schemaFilePath, printSchemaWithDirectives(schema));
-		}
+		if (downloadMode === "always" ? !fileExists || needsUpdate(schemas, headers, schemaFilePath) : !fileExists) writeFileIfChanged(schemaFilePath, printSchemaWithDirectives(loadWithLoaders(schemas, headers)));
 		return schemaFilePath;
 	} catch {
 		return;
 	}
 }
-
+/**
+* Check if a cached schema needs to be updated
+* For URL sources: compare MD5 hashes. For local files: compare mtime.
+*/
+function needsUpdate(schemas, headers, cachedPath) {
+	const hasUrls = schemas.some(isUrl);
+	const hasLocal = schemas.some((s) => !isUrl(s));
+	if (hasUrls) try {
+		const remoteSchema = loadSchemaSync(schemas.filter(isUrl), {
+			loaders: [new UrlLoader()],
+			...Object.keys(headers).length > 0 && { headers }
+		});
+		return createHash("md5").update(printSchemaWithDirectives(remoteSchema)).digest("hex") !== createHash("md5").update(readFileSync(cachedPath, "utf-8")).digest("hex");
+	} catch {
+		return true;
+	}
+	if (hasLocal) {
+		const cachedStats = statSync(cachedPath);
+		return schemas.filter((s) => !isUrl(s)).some((localFile) => {
+			return existsSync(localFile) && statSync(localFile).mtime > cachedStats.mtime;
+		});
+	}
+	return true;
+}
 //#endregion
-export { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema };
+export { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema };

package/dist/core/codegen/server-type-helpers.d.mts

@@ -0,0 +1,14 @@
+//#region src/core/codegen/server-type-helpers.d.ts
+/**
+ * Server type helpers prepended to generated resolver types
+ *
+ * These TypeScript types power the ResolverReturnType<T> mapped type
+ * that integrates Standard Schema (Zod, Valibot, etc.) validation
+ * output types into resolvers.
+ */
+/**
+ * Generate the imports + type helpers prepended to server type output
+ */
+declare function generateServerPrepend(framework: string): string;
+//#endregion
+export { generateServerPrepend };

package/dist/core/codegen/server-type-helpers.mjs

@@ -0,0 +1,76 @@
+//#region src/core/codegen/server-type-helpers.ts
+/**
+* Server type helpers prepended to generated resolver types
+*
+* These TypeScript types power the ResolverReturnType<T> mapped type
+* that integrates Standard Schema (Zod, Valibot, etc.) validation
+* output types into resolvers.
+*/
+/**
+* Generate the imports + type helpers prepended to server type output
+*/
+function generateServerPrepend(framework) {
+	return `import schemas from '#nitro-graphql/validation-schemas'
+import type { StandardSchemaV1 } from 'nitro-graphql/types'
+
+export interface NPMConfig {
+  framework: '${framework || "graphql-yoga"}';
+}
+
+export type SchemaType = Partial<Record<Partial<keyof ResolversTypes>, StandardSchemaV1>>
+
+// Resolve schema keys safely — returns never for empty schema objects
+type SafeSchemaKeys<T> = T extends Record<PropertyKey, never>
+  ? never
+  : keyof T extends string | number | symbol
+    ? keyof T extends never
+      ? never
+      : keyof T
+    : never;
+
+type SchemaKeys = SafeSchemaKeys<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;
+
+/**
+ * Maps resolver return types through Standard Schema validation.
+ * When a type's __typename matches a schema key, its output type
+ * is inferred from the schema's validation output instead.
+ */
+type ResolverReturnType<T> = T extends BuiltIns
+  ? T
+  : T extends (...args: any[]) => unknown
+    ? T | undefined
+    : T extends object
+      ? T extends Array<infer ItemType>
+        ? ItemType[] extends T
+          ? Array<ResolverReturnType<ItemType>>
+          : ResolverReturnTypeObject<T>
+        : ResolverReturnTypeObject<T>
+      : unknown;
+
+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]> };
+`;
+}
+//#endregion
+export { generateServerPrepend };

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

@@ -1,5 +1,4 @@
 import { ServerCodegenConfig, ServerCodegenInput, ServerCodegenResult } from "../types/codegen.mjs";
-import { GraphQLSchema } from "graphql";
 
 //#region src/core/codegen/server.d.ts
 /**
@@ -8,20 +7,7 @@ import { GraphQLSchema } from "graphql";
 declare const DEFAULT_SERVER_CODEGEN_CONFIG: ServerCodegenConfig;
 /**
  * Generate server-side GraphQL types
- * Pure function that generates TypeScript types from a GraphQL schema
  */
 declare function generateServerTypesCore(input: ServerCodegenInput): Promise<ServerCodegenResult>;
-/**
- * Generate types from schema (simplified version for direct use)
- * @deprecated Use generateServerTypesCore instead
- */
-declare function generateTypes(framework: string, schema: GraphQLSchema, config?: {
-  codegen?: {
-    server?: ServerCodegenConfig;
-  };
-  federation?: {
-    enabled?: boolean;
-  };
-}, outputPath?: string): Promise<string>;
 //#endregion
-export { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore, generateTypes };
+export { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore };

package/dist/core/codegen/server.mjs

@@ -1,12 +1,12 @@
 import { DEFAULT_GRAPHQL_SCALARS } from "../constants.mjs";
-import { pluginContent } from "./plugin.mjs";
+import { GENERATED_FILE_HEADER } from "./file-header.mjs";
+import { generateServerPrepend } from "./server-type-helpers.mjs";
 import { defu as defu$1 } from "defu";
 import { codegen } from "@graphql-codegen/core";
 import * as typescriptPlugin from "@graphql-codegen/typescript";
 import { printSchemaWithDirectives } from "@graphql-tools/utils";
 import { parse } from "graphql";
 import * as typescriptResolversPlugin from "@graphql-codegen/typescript-resolvers";
-
 //#region src/core/codegen/server.ts
 /**
 * Default server codegen configuration
@@ -23,7 +23,6 @@ const DEFAULT_SERVER_CODEGEN_CONFIG = {
 };
 /**
 * Generate server-side GraphQL types
-* Pure function that generates TypeScript types from a GraphQL schema
 */
 async function generateServerTypesCore(input) {
 	const { framework, schema, schemaString: inputSchemaString, config = {}, federationEnabled = false, outputPath } = input;
@@ -33,112 +32,21 @@ async function generateServerTypesCore(input) {
 	}, config);
 	const schemaString = inputSchemaString || (schema ? printSchemaWithDirectives(schema) : null);
 	if (!schemaString) throw new Error("[generateServerTypesCore] No schema or schemaString provided");
+	const generated = await codegen({
+		filename: outputPath || "types.generated.ts",
+		schema: parse(schemaString),
+		documents: [],
+		config: mergedConfig,
+		plugins: [{ typescript: {} }, { typescriptResolvers: {} }],
+		pluginMap: {
+			typescript: typescriptPlugin,
+			typescriptResolvers: typescriptResolversPlugin
+		}
+	});
 	return {
-		types: await codegen({
-			filename: outputPath || "types.generated.ts",
-			schema: parse(schemaString),
-			documents: [],
-			config: mergedConfig,
-			plugins: [
-				{ imports: {} },
-				{ pluginContent: {} },
-				{ typescript: {} },
-				{ typescriptResolvers: {} }
-			],
-			pluginMap: {
-				pluginContent: { plugin: pluginContent },
-				imports: { plugin: () => {
-					return {
-						prepend: [
-							`import schemas from '#nitro-graphql/validation-schemas'`,
-							`import type { StandardSchemaV1 } from 'nitro-graphql/types'`,
-							generateServerTypeHelpers(framework),
-							""
-						],
-						content: ""
-					};
-				} },
-				typescript: typescriptPlugin,
-				typescriptResolvers: typescriptResolversPlugin
-			}
-		}),
+		types: GENERATED_FILE_HEADER + generateServerPrepend(framework) + generated,
 		schemaString
 	};
 }
-/**
-* Generate server type helper code
-*/
-function generateServerTypeHelpers(framework) {
-	return `
-export interface NPMConfig {
-  framework: '${framework || "graphql-yoga"}';
-}
-
-export type SchemaType = Partial<Record<Partial<keyof ResolversTypes>, StandardSchemaV1>>
-
-// Check if schemas is empty object, return never if so
-type SafeSchemaKeys<T> = T extends Record<PropertyKey, never>
-  ? never
-  : keyof T extends string | number | symbol
-    ? keyof T extends never
-      ? never
-      : keyof T
-    : never;
-
-
-type SchemaKeys = SafeSchemaKeys<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;
-
-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]> };
-`;
-}
-/**
-* Generate types from schema (simplified version for direct use)
-* @deprecated Use generateServerTypesCore instead
-*/
-async function generateTypes(framework, schema, config = {}, outputPath) {
-	return (await generateServerTypesCore({
-		framework,
-		schema,
-		config: config.codegen?.server,
-		federationEnabled: config.federation?.enabled,
-		outputPath
-	})).types;
-}
-
 //#endregion
-export { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore, generateTypes };
+export { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore };

package/dist/core/codegen/subscription-extractor.d.mts

@@ -0,0 +1,20 @@
+import { Source } from "@graphql-tools/utils";
+
+//#region src/core/codegen/subscription-extractor.d.ts
+/**
+ * Subscription info extracted from GraphQL documents
+ */
+interface SubscriptionInfo {
+  /** Original operation name from GraphQL document (used for method names) */
+  name: string;
+  /** PascalCase version for type references (matches GraphQL codegen output) */
+  typeName: string;
+  fieldName: string;
+  hasVariables: boolean;
+}
+/**
+ * Extract subscription operations from GraphQL documents
+ */
+declare function extractSubscriptions(docs: Source[]): SubscriptionInfo[];
+//#endregion
+export { SubscriptionInfo, extractSubscriptions };

package/dist/core/codegen/subscription-extractor.mjs

@@ -0,0 +1,30 @@
+import { capitalize } from "../utils/string.mjs";
+import { Kind } from "graphql";
+//#region src/core/codegen/subscription-extractor.ts
+/**
+* Extract subscription operations from GraphQL documents
+*/
+function extractSubscriptions(docs) {
+	const subscriptions = [];
+	for (const doc of docs) {
+		if (!doc.document) continue;
+		for (const def of doc.document.definitions) if (def.kind === Kind.OPERATION_DEFINITION && def.operation === "subscription") {
+			const operationDef = def;
+			const name = operationDef.name?.value;
+			if (!name) continue;
+			const firstSelection = operationDef.selectionSet.selections[0];
+			if (firstSelection.kind !== Kind.FIELD) continue;
+			const fieldName = firstSelection.name.value;
+			const hasVariables = (operationDef.variableDefinitions?.length || 0) > 0;
+			subscriptions.push({
+				name,
+				typeName: capitalize(name),
+				fieldName,
+				hasVariables
+			});
+		}
+	}
+	return subscriptions;
+}
+//#endregion
+export { extractSubscriptions };

package/dist/core/codegen/validation.mjs

@@ -1,6 +1,5 @@
 import consola from "consola";
 import { validateSchemaStringWithPaths, validateSchemas } from "nitro-graphql/native";
-
 //#region src/core/codegen/validation.ts
 /**
 * GraphQL schema validation utilities
@@ -30,6 +29,5 @@ function validateSchemaFiles(filePaths) {
 	}
 	return true;
 }
-
 //#endregion
-export { validateNoDuplicateTypes, validateSchemaFiles };
+export { validateNoDuplicateTypes, validateSchemaFiles };

package/dist/core/codegen/vue-subscription-builder.d.mts

@@ -0,0 +1,10 @@
+import { Source } from "@graphql-tools/utils";
+
+//#region src/core/codegen/vue-subscription-builder.d.ts
+/**
+ * Generate subscription builder code (Drizzle-style API) + Vue Composables
+ * Returns empty string if subscriptions are not enabled or no subscription operations found
+ */
+declare function generateSubscriptionBuilder(docs: Source[], subscriptionsEnabled: boolean): string;
+//#endregion
+export { generateSubscriptionBuilder };