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

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

@@ -0,0 +1,17 @@
+import { ScannedResolver } from "../types/scanning.mjs";
+//#region src/core/codegen/runtime.d.ts
+/**
+ * Generate resolver module code
+ * Outputs Nitro-compatible format with { resolver: ... } wrapper
+ */
+declare function generateResolverModule(resolvers: ScannedResolver[], baseDir: string): string;
+/**
+ * Generate schema module code
+ */
+declare function generateSchemaModule(schemaString: string): string;
+/**
+ * Generate runtime index module
+ */
+declare function generateRuntimeIndex(): string;
+//#endregion
+export { generateResolverModule, generateRuntimeIndex, generateSchemaModule };

package/dist/core/codegen/runtime.mjs

@@ -0,0 +1,61 @@
+import { relative } from "pathe";
+//#region src/core/codegen/runtime.ts
+const TS_EXTENSION_RE = /\.ts$/;
+const BACKTICK_RE = /`/g;
+const DOLLAR_SIGN_RE = /\$/g;
+/**
+* Generate resolver module code
+* Outputs Nitro-compatible format with { resolver: ... } wrapper
+*/
+function generateResolverModule(resolvers, baseDir) {
+	if (!resolvers.length) return `// Auto-generated by nitro-graphql - no resolvers found
+export const resolvers = []
+`;
+	const imports = [];
+	const resolverEntries = [];
+	const reexports = [];
+	for (const resolver of resolvers) {
+		const relativePath = relative(baseDir, resolver.specifier).replace(TS_EXTENSION_RE, "");
+		const exportNames = resolver.imports.map((i) => i.name);
+		if (exportNames.length > 0) {
+			imports.push(`import { ${exportNames.join(", ")} } from '${relativePath}'`);
+			for (const name of exportNames) resolverEntries.push(`  { resolver: ${name} }`);
+			reexports.push(`export { ${exportNames.join(", ")} } from '${relativePath}'`);
+		}
+	}
+	return `// Auto-generated by nitro-graphql - do not edit
+${imports.join("\n")}
+
+export const resolvers = [
+${resolverEntries.join(",\n")},
+]
+
+// Re-exports for tree-shaking
+${reexports.join("\n")}
+`;
+}
+/**
+* Generate schema module code
+*/
+function generateSchemaModule(schemaString) {
+	return `// Auto-generated by nitro-graphql - do not edit
+export const schemaString = \`
+${schemaString.replace(BACKTICK_RE, "\\`").replace(DOLLAR_SIGN_RE, "\\$")}
+\`
+
+// Pre-parsed for convenience
+import { parse } from 'graphql'
+export const typeDefs = parse(schemaString)
+`;
+}
+/**
+* Generate runtime index module
+*/
+function generateRuntimeIndex() {
+	return `// Auto-generated by nitro-graphql - do not edit
+export { resolvers } from './resolvers'
+export { schemaString, typeDefs } from './schema'
+`;
+}
+//#endregion
+export { generateResolverModule, generateRuntimeIndex, generateSchemaModule };

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

@@ -0,0 +1,27 @@
+import { ExternalServiceCodegenConfig } from "../types/codegen.mjs";
+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
+ */
+declare function graphQLLoadSchemaSync(schemaPointers: GraphQLTypeDefPointer, data?: GraphQLLoadSchemaOptions): GraphQLSchema | undefined;
+/**
+ * Load schema from external GraphQL service
+ */
+declare function loadExternalSchema(service: ExternalServiceCodegenConfig, buildDir?: string): Promise<GraphQLSchema | undefined>;
+/**
+ * Download and save schema from external service
+ */
+declare function downloadAndSaveSchema(service: ExternalServiceCodegenConfig, buildDir: string): Promise<string | undefined>;
+//#endregion
+export { GraphQLLoadSchemaOptions, GraphQLTypeDefPointer, downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema };

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

@@ -0,0 +1,126 @@
+import { writeFileIfChanged } from "../utils/file-io.mjs";
+import { resolve } from "pathe";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
+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://");
+}
+/**
+* Load GraphQL schema synchronously
+*/
+function graphQLLoadSchemaSync(schemaPointers, data = {}) {
+	const filteredPointers = [...Array.isArray(schemaPointers) ? schemaPointers : [schemaPointers], "!**/vfs/**"];
+	try {
+		return loadSchemaSync(filteredPointers, {
+			...data,
+			loaders: [
+				new GraphQLFileLoader(),
+				new UrlLoader(),
+				...data.loaders || []
+			]
+		});
+	} catch (e) {
+		if ((e.message || "").includes("Unable to find any GraphQL type definitions for the following pointers:")) return;
+		throw e;
+	}
+}
+/**
+* Load schema from external GraphQL service
+*/
+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];
+		if (service.downloadSchema && buildDir) {
+			const defaultPath = resolve(buildDir, "graphql", "schemas", `${service.name}.graphql`);
+			const schemaFilePath = service.downloadPath ? resolve(service.downloadPath) : defaultPath;
+			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 }
+		});
+	} catch {
+		return;
+	}
+}
+/**
+* Download and save schema from external service
+*/
+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;
+	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 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));
+		}
+		return schemaFilePath;
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema };

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

@@ -0,0 +1,27 @@
+import { ServerCodegenConfig, ServerCodegenInput, ServerCodegenResult } from "../types/codegen.mjs";
+import { GraphQLSchema } from "graphql";
+
+//#region src/core/codegen/server.d.ts
+/**
+ * Default server codegen configuration
+ */
+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 };

package/dist/core/codegen/server.mjs

@@ -0,0 +1,142 @@
+import { DEFAULT_GRAPHQL_SCALARS } from "../constants.mjs";
+import { pluginContent } from "./plugin.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
+*/
+const DEFAULT_SERVER_CODEGEN_CONFIG = {
+	scalars: DEFAULT_GRAPHQL_SCALARS,
+	defaultScalarType: "unknown",
+	defaultMapper: `ResolverReturnType<{T}>`,
+	contextType: "nitro/h3#H3Event",
+	maybeValue: "T | null | undefined",
+	inputMaybeValue: "T | undefined",
+	declarationKind: "interface",
+	enumsAsTypes: true
+};
+/**
+* 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;
+	const mergedConfig = defu$1({
+		...DEFAULT_SERVER_CODEGEN_CONFIG,
+		...federationEnabled && { federation: true }
+	}, config);
+	const schemaString = inputSchemaString || (schema ? printSchemaWithDirectives(schema) : null);
+	if (!schemaString) throw new Error("[generateServerTypesCore] No schema or schemaString provided");
+	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
+			}
+		}),
+		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 };

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

@@ -0,0 +1,17 @@
+//#region src/core/codegen/validation.d.ts
+/**
+ * GraphQL schema validation utilities
+ * Uses native Rust validator (apollo-compiler) for fast validation
+ */
+/**
+ * Validate GraphQL schemas using native Rust validator (apollo-compiler)
+ * @returns true if validation passes, false if errors found
+ */
+declare function validateNoDuplicateTypes(schemas: string[], schemaStrings: string[]): boolean;
+/**
+ * Validate GraphQL schema files directly
+ * @returns true if validation passes, false if errors found
+ */
+declare function validateSchemaFiles(filePaths: string[]): boolean;
+//#endregion
+export { validateNoDuplicateTypes, validateSchemaFiles };

package/dist/core/codegen/validation.mjs

@@ -0,0 +1,33 @@
+import consola from "consola";
+import { validateSchemaStringWithPaths, validateSchemas } from "nitro-graphql/native";
+//#region src/core/codegen/validation.ts
+/**
+* GraphQL schema validation utilities
+* Uses native Rust validator (apollo-compiler) for fast validation
+*/
+/**
+* Validate GraphQL schemas using native Rust validator (apollo-compiler)
+* @returns true if validation passes, false if errors found
+*/
+function validateNoDuplicateTypes(schemas, schemaStrings) {
+	const result = validateSchemaStringWithPaths(schemaStrings, schemas);
+	if (!result.valid) {
+		for (const error of result.errors) consola.error(error);
+		return false;
+	}
+	return true;
+}
+/**
+* Validate GraphQL schema files directly
+* @returns true if validation passes, false if errors found
+*/
+function validateSchemaFiles(filePaths) {
+	const result = validateSchemas(filePaths);
+	if (!result.valid) {
+		for (const error of result.errors) consola.error(error);
+		return false;
+	}
+	return true;
+}
+//#endregion
+export { validateNoDuplicateTypes, validateSchemaFiles };

package/dist/core/config.d.mts

@@ -0,0 +1,45 @@
+import { CoreConfig, CoreContext, CoreGraphQLOptions, CoreLogger } from "./types/config.mjs";
+import { ScanContext } from "./types/scanning.mjs";
+
+//#region src/core/config.d.ts
+/**
+ * Options for creating a CoreConfig
+ */
+interface CreateCoreConfigOptions {
+  /** Root directory of the project */
+  rootDir: string;
+  /** Build directory (optional, defaults based on framework) */
+  buildDir?: string;
+  /** Server GraphQL directory (optional) */
+  serverDir?: string;
+  /** Client GraphQL directory (optional) */
+  clientDir?: string;
+  /** Whether running in Nuxt context */
+  isNuxt?: boolean;
+  /** Whether running in development mode */
+  isDev?: boolean;
+  /** GraphQL options */
+  graphqlOptions?: CoreGraphQLOptions;
+  /** Custom logger */
+  logger?: CoreLogger;
+  /** Patterns to ignore */
+  ignorePatterns?: string[];
+}
+/**
+ * Create a CoreConfig with sensible defaults
+ */
+declare function createCoreConfig(options: CreateCoreConfigOptions): CoreConfig;
+/**
+ * Create a CoreContext from CoreConfig
+ */
+declare function createCoreContext(config: CoreConfig): CoreContext;
+/**
+ * Create a ScanContext from CoreConfig
+ */
+declare function createScanContext(config: CoreConfig): ScanContext;
+/**
+ * Merge GraphQL options with defaults
+ */
+declare function mergeGraphQLOptions(options: Partial<CoreGraphQLOptions>, defaults?: Partial<CoreGraphQLOptions>): CoreGraphQLOptions;
+//#endregion
+export { CreateCoreConfigOptions, createCoreConfig, createCoreContext, createScanContext, mergeGraphQLOptions };

package/dist/core/config.mjs

@@ -0,0 +1,76 @@
+import "./constants.mjs";
+import { createLogger } from "./utils/logger.mjs";
+import { relative, resolve } from "pathe";
+//#region src/core/config.ts
+/**
+* Create a CoreConfig with sensible defaults
+*/
+function createCoreConfig(options) {
+	const { rootDir, isNuxt = false, isDev = process.env.NODE_ENV !== "production", graphqlOptions = {}, logger = createLogger(), ignorePatterns = [] } = options;
+	const framework = graphqlOptions.framework || "graphql-yoga";
+	const buildDir = options.buildDir || resolve(rootDir, isNuxt ? ".nuxt" : ".nitro");
+	return {
+		rootDir,
+		buildDir,
+		serverDir: options.serverDir || resolve(rootDir, "server/graphql"),
+		clientDir: options.clientDir || resolve(rootDir, isNuxt ? "app/graphql" : "graphql"),
+		typesDir: resolve(buildDir, "types"),
+		framework,
+		isNuxt,
+		isDev,
+		graphqlOptions,
+		logger,
+		ignorePatterns
+	};
+}
+/**
+* Create a CoreContext from CoreConfig
+*/
+function createCoreContext(config) {
+	return {
+		config,
+		graphqlBuildDir: resolve(config.buildDir, "graphql"),
+		watchDirs: [],
+		dir: {
+			build: relative(config.rootDir, config.buildDir),
+			client: relative(config.rootDir, config.clientDir),
+			server: relative(config.rootDir, config.serverDir)
+		}
+	};
+}
+/**
+* Create a ScanContext from CoreConfig
+*/
+function createScanContext(config) {
+	return {
+		rootDir: config.rootDir,
+		serverDir: config.serverDir,
+		clientDir: config.clientDir,
+		ignorePatterns: config.ignorePatterns,
+		isDev: config.isDev,
+		logger: config.logger
+	};
+}
+/**
+* Merge GraphQL options with defaults
+*/
+function mergeGraphQLOptions(options, defaults = {}) {
+	return {
+		...defaults,
+		...options,
+		codegen: {
+			...defaults.codegen,
+			...options.codegen
+		},
+		security: {
+			...defaults.security,
+			...options.security
+		},
+		paths: {
+			...defaults.paths,
+			...options.paths
+		}
+	};
+}
+//#endregion
+export { createCoreConfig, createCoreContext, createScanContext, mergeGraphQLOptions };