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

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

@@ -0,0 +1,128 @@
+import { writeFile } 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()] });
+			writeFile(schemaFilePath, printSchemaWithDirectives(schema));
+		}
+		return schemaFilePath;
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+export { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema };

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

@@ -0,0 +1,28 @@
+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,143 @@
+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, config = {}, federationEnabled = false, outputPath } = input;
+	const mergedConfig = defu$1({
+		...DEFAULT_SERVER_CODEGEN_CONFIG,
+		...federationEnabled && { federation: true }
+	}, config);
+	const schemaString = printSchemaWithDirectives(schema);
+	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 '#graphql/schema'`,
+							`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,13 @@
+//#region src/core/codegen/validation.d.ts
+/**
+ * GraphQL schema validation utilities
+ * Validates schemas for duplicate type definitions and conflicts
+ */
+/**
+ * Check for duplicate type definitions using a simpler approach
+ * Try to build each schema individually - if that succeeds but merging fails, we have duplicates
+ * @returns true if validation passes, false if duplicates found
+ */
+declare function validateNoDuplicateTypes(schemas: string[], schemaStrings: string[]): boolean;
+//#endregion
+export { validateNoDuplicateTypes };

package/dist/core/codegen/validation.mjs

@@ -0,0 +1,96 @@
+import { BUILTIN_SCALARS } from "../constants.mjs";
+import consola from "consola";
+import { basename } from "pathe";
+import { parse } from "graphql";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+
+//#region src/core/codegen/validation.ts
+/**
+* GraphQL schema validation utilities
+* Validates schemas for duplicate type definitions and conflicts
+*/
+/**
+* Check for duplicate type definitions using a simpler approach
+* Try to build each schema individually - if that succeeds but merging fails, we have duplicates
+* @returns true if validation passes, false if duplicates found
+*/
+function validateNoDuplicateTypes(schemas, schemaStrings) {
+	const individualSchemasByFile = /* @__PURE__ */ new Map();
+	schemaStrings.forEach((schemaContent, index) => {
+		const schemaPath = schemas[index];
+		const fileName = basename(schemaPath);
+		try {
+			parse(schemaContent);
+			individualSchemasByFile.set(fileName, schemaContent);
+		} catch (error) {
+			consola.warn(`Invalid GraphQL syntax in ${fileName}:`, error);
+			throw error;
+		}
+	});
+	try {
+		mergeTypeDefs([schemaStrings.join("\n\n")], {
+			throwOnConflict: false,
+			commentDescriptions: true,
+			sort: true
+		});
+		mergeTypeDefs([schemaStrings.join("\n\n")], {
+			throwOnConflict: true,
+			commentDescriptions: true,
+			sort: true
+		});
+	} catch (conflictError) {
+		if (conflictError?.message?.includes("already defined with a different type")) throw conflictError;
+	}
+	const typeNames = /* @__PURE__ */ new Set();
+	const duplicateTypes = [];
+	schemaStrings.forEach((schemaContent, index) => {
+		const fileName = basename(schemas[index]);
+		try {
+			parse(schemaContent).definitions.forEach((def) => {
+				if (def.kind === "ObjectTypeDefinition" || def.kind === "InterfaceTypeDefinition" || def.kind === "UnionTypeDefinition" || def.kind === "EnumTypeDefinition" || def.kind === "InputObjectTypeDefinition" || def.kind === "ScalarTypeDefinition") {
+					const typeName = def.name.value;
+					if (BUILTIN_SCALARS.includes(typeName)) return;
+					if (typeNames.has(typeName)) {
+						const existing = duplicateTypes.find((d) => d.type === typeName);
+						if (existing) existing.files.push(fileName);
+						else {
+							const firstFile = schemas.find((_, i) => {
+								const content = schemaStrings[i];
+								if (!content) return false;
+								try {
+									return parse(content).definitions.some((d) => (d.kind === "ObjectTypeDefinition" || d.kind === "InterfaceTypeDefinition" || d.kind === "UnionTypeDefinition" || d.kind === "EnumTypeDefinition" || d.kind === "InputObjectTypeDefinition" || d.kind === "ScalarTypeDefinition") && d.name.value === typeName);
+								} catch {
+									return false;
+								}
+							});
+							duplicateTypes.push({
+								type: typeName,
+								files: [basename(firstFile || ""), fileName]
+							});
+						}
+					} else typeNames.add(typeName);
+				}
+			});
+		} catch {}
+	});
+	if (duplicateTypes.length > 0) {
+		let errorMessage = "⚠️  DUPLICATE TYPE DEFINITIONS DETECTED!\n\n";
+		duplicateTypes.forEach(({ type, files }) => {
+			errorMessage += `❌ Type "${type}" is defined in multiple files:\n`;
+			files.forEach((fileName) => {
+				const fullPath = schemas.find((path) => basename(path) === fileName) || fileName;
+				errorMessage += `   • ${fullPath}\n`;
+			});
+			errorMessage += "\n";
+		});
+		errorMessage += "💡 Each GraphQL type should only be defined once.\n";
+		errorMessage += "   Consider using \"extend type\" syntax instead of duplicate definitions.\n";
+		errorMessage += `\n🔍 Found ${duplicateTypes.length} duplicate type(s): ${duplicateTypes.map((d) => d.type).join(", ")}`;
+		consola.error(errorMessage);
+		return false;
+	}
+	return true;
+}
+
+//#endregion
+export { validateNoDuplicateTypes };

package/dist/core/config.d.mts

@@ -0,0 +1,50 @@
+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[];
+  /** Layer server directories */
+  layerServerDirs?: string[];
+  /** Layer app directories */
+  layerAppDirs?: 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,82 @@
+import { DIR_APP_GRAPHQL, DIR_BUILD_NITRO, DIR_CLIENT_GRAPHQL, DIR_SERVER_GRAPHQL, GRAPHQL_FRAMEWORK_YOGA } from "./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 = [], layerServerDirs = [], layerAppDirs = [] } = options;
+	const framework = graphqlOptions.framework || GRAPHQL_FRAMEWORK_YOGA;
+	const buildDir = options.buildDir || resolve(rootDir, isNuxt ? ".nuxt" : DIR_BUILD_NITRO);
+	return {
+		rootDir,
+		buildDir,
+		serverDir: options.serverDir || resolve(rootDir, DIR_SERVER_GRAPHQL),
+		clientDir: options.clientDir || resolve(rootDir, isNuxt ? DIR_APP_GRAPHQL : DIR_CLIENT_GRAPHQL),
+		typesDir: resolve(buildDir, "types"),
+		framework,
+		isNuxt,
+		isDev,
+		graphqlOptions,
+		logger,
+		ignorePatterns,
+		layerServerDirs,
+		layerAppDirs
+	};
+}
+/**
+* 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,
+		layerServerDirs: config.layerServerDirs,
+		layerAppDirs: config.layerAppDirs
+	};
+}
+/**
+* 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 };