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

package/README.md

@@ -620,7 +620,7 @@ export default defineNitroConfig({
 > **⚠️ Breaking Change**: Utilities are **NOT auto-imported**. You must explicitly import them from `nitro-graphql/define`:
 
 ```typescript
-import { defineResolver, defineQuery, defineMutation, defineType, defineDirective } from 'nitro-graphql/define'
+import { defineResolver, defineQuery, defineMutation, defineField, defineDirective } from 'nitro-graphql/define'
 ```
 
 | Function | Purpose | Example |
@@ -628,7 +628,7 @@ import { defineResolver, defineQuery, defineMutation, defineType, defineDirectiv
 | `defineResolver` | Complete resolvers | `defineResolver({ Query: {...}, Mutation: {...} })` |
 | `defineQuery` | Query-only resolvers | `defineQuery({ users: () => [...] })` |
 | `defineMutation` | Mutation-only resolvers | `defineMutation({ createUser: (...) => {...} })` |
-| `defineType` | Custom type resolvers | `defineType({ User: { posts: (parent) => [...] } })` |
+| `defineField` | Custom type resolvers | `defineField({ User: { posts: (parent) => [...] } })` |
 | `defineDirective` | Custom directives | `defineDirective({ name: 'auth', ... })` |
 | `defineGraphQLConfig` | GraphQL server config | `defineGraphQLConfig({ maskedErrors: {...} })` |
 | `defineSchema` | Schema with Zod integration | `defineSchema({ Book: selectBookSchema })` |
@@ -777,7 +777,7 @@ This error occurs when the resolver scanner can't find the expected export in yo
   - `defineResolver` - Complete resolver with Query, Mutation, etc.
   - `defineQuery` - Query-only resolvers
   - `defineMutation` - Mutation-only resolvers
-  - `defineType` - Custom type resolvers
+  - `defineField` - Custom type resolvers
   - `defineSubscription` - Subscription resolvers
   - `defineDirective` - Directive resolvers
 - Only exports using these functions are included in the virtual module

package/dist/codegen/client-types.d.mts

@@ -0,0 +1,13 @@
+import { Nitro } from "nitro/types";
+
+//#region src/codegen/client-types.d.ts
+
+/**
+ * Generate main client types (for the default service)
+ */
+declare function generateMainClientTypes(nitro: Nitro, options?: {
+  silent?: boolean;
+  isInitial?: boolean;
+}): Promise<void>;
+//#endregion
+export { generateMainClientTypes };

package/dist/codegen/client-types.mjs

@@ -0,0 +1,176 @@
+import { FILE_INDEX_TS, LOG_TAG, SERVICE_DEFAULT } from "../constants.mjs";
+import { generateClientTypes, loadGraphQLDocuments } from "../utils/client-codegen.mjs";
+import { writeFileIfNotExists } from "../utils/file-generator.mjs";
+import { getClientUtilsConfig, getDefaultPaths, getSdkConfig, getTypesConfig, resolveFilePath, shouldGenerateClientUtils } from "../utils/path-resolver.mjs";
+import consola from "consola";
+import { dirname, join, resolve } from "pathe";
+import { buildSchema, parse } from "graphql";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+
+//#region src/codegen/client-types.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Load federation support for client-side schema building
+*/
+async function loadFederationSupport() {
+	try {
+		return (await import("@apollo/subgraph")).buildSubgraphSchema;
+	} catch {
+		return false;
+	}
+}
+/**
+* Check for old structure files and warn user about manual migration
+*/
+function warnLegacyGraphQLStructure(clientDir) {
+	const oldOfetchPath = resolve(clientDir, "ofetch.ts");
+	const oldSdkPath = resolve(clientDir, "sdk.ts");
+	if (existsSync(oldOfetchPath) || existsSync(oldSdkPath)) {
+		const foundFiles = [];
+		if (existsSync(oldOfetchPath)) foundFiles.push("app/graphql/ofetch.ts");
+		if (existsSync(oldSdkPath)) foundFiles.push("app/graphql/sdk.ts");
+		consola.error(`⚠️  OLD GRAPHQL STRUCTURE DETECTED!
+
+📁 Found old files in app/graphql/ directory that need to be moved:
+   • ${foundFiles.join("\n   • ")}
+
+🔄 Please manually move these files to the new structure:
+   • app/graphql/ofetch.ts → app/graphql/default/ofetch.ts
+   • app/graphql/sdk.ts → app/graphql/default/sdk.ts
+
+📝 Also update your app/graphql/index.ts to include:
+   export * from './default/ofetch'
+
+💡 After moving, update your imports to use:
+   import { $sdk } from "#graphql/client"
+
+🚫 The old files will cause import conflicts until moved!`);
+	}
+}
+/**
+* Generate main client types (for the default service)
+*/
+async function generateMainClientTypes(nitro, options = {}) {
+	warnLegacyGraphQLStructure(nitro.graphql.clientDir);
+	const docs = nitro.scanDocuments;
+	const loadedDocs = await loadGraphQLDocuments(docs);
+	const schemaFilePath = join(nitro.graphql.buildDir, "schema.graphql");
+	if (!existsSync(schemaFilePath)) {
+		if (!options.silent) consola.info("Schema file not ready yet for client type generation. Server types need to be generated first.");
+		return;
+	}
+	const graphqlString = readFileSync(schemaFilePath, "utf-8");
+	const federationEnabled = nitro.options.graphql?.federation?.enabled === true;
+	let schema;
+	if (federationEnabled) {
+		const buildSubgraph = await loadFederationSupport();
+		if (!buildSubgraph) throw new Error("Federation is enabled but @apollo/subgraph is not installed. Run: pnpm add @apollo/subgraph");
+		schema = buildSubgraph([{ typeDefs: parse(graphqlString) }]);
+	} else schema = buildSchema(graphqlString);
+	const types = await generateClientTypes(schema, loadedDocs, nitro.options.graphql?.codegen?.client ?? {}, nitro.options.graphql?.codegen?.clientSDK ?? {}, void 0, void 0, void 0, options);
+	if (types === false) return;
+	const placeholders = getDefaultPaths(nitro);
+	const typesConfig = getTypesConfig(nitro);
+	const sdkConfig = getSdkConfig(nitro);
+	const clientTypesPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
+	if (clientTypesPath) {
+		mkdirSync(dirname(clientTypesPath), { recursive: true });
+		writeFileSync(clientTypesPath, types.types, "utf-8");
+		if (!options.silent) logger.success(`Generated client types at: ${clientTypesPath}`);
+	}
+	const sdkPath = resolveFilePath(sdkConfig.main, sdkConfig.enabled, true, "{clientGraphql}/default/sdk.ts", placeholders);
+	if (sdkPath) {
+		mkdirSync(dirname(sdkPath), { recursive: true });
+		writeFileSync(sdkPath, types.sdk, "utf-8");
+		if (!options.silent) logger.success(`Generated SDK at: ${sdkPath}`);
+	}
+	generateNuxtOfetchClient(nitro, nitro.graphql.clientDir, SERVICE_DEFAULT);
+	const externalServices = nitro.options.graphql?.externalServices || [];
+	if (externalServices.length > 0) generateGraphQLIndexFile(nitro, nitro.graphql.clientDir, externalServices);
+}
+/**
+* Generate GraphQL index file that exports all services
+*/
+function generateGraphQLIndexFile(nitro, clientDir, externalServices = []) {
+	if (!shouldGenerateClientUtils(nitro)) return;
+	const placeholders = getDefaultPaths(nitro);
+	const clientUtilsConfig = getClientUtilsConfig(nitro);
+	const indexPath = resolveFilePath(clientUtilsConfig.index, clientUtilsConfig.enabled, true, `{clientGraphql}/${FILE_INDEX_TS}`, placeholders);
+	if (!indexPath) return;
+	if (!existsSync(indexPath)) {
+		let indexContent = `// This file is auto-generated once by nitro-graphql for quick start
+// You can modify this file according to your needs
+//
+// Export your main GraphQL service (auto-generated)
+export * from './default/ofetch'
+
+// Export external GraphQL services (auto-generated for existing services)
+// When you add new external services, don't forget to add their exports here:
+// export * from './yourServiceName/ofetch'
+`;
+		for (const service of externalServices) indexContent += `export * from './${service.name}/ofetch'\n`;
+		writeFileIfNotExists(indexPath, indexContent, `client ${FILE_INDEX_TS}`);
+	}
+}
+/**
+* Generate ofetch client wrapper for Nuxt/Nitro
+*/
+function generateNuxtOfetchClient(nitro, clientDir, serviceName = SERVICE_DEFAULT) {
+	if (!shouldGenerateClientUtils(nitro)) return;
+	const placeholders = {
+		...getDefaultPaths(nitro),
+		serviceName
+	};
+	const clientUtilsConfig = getClientUtilsConfig(nitro);
+	const ofetchPath = resolveFilePath(clientUtilsConfig.ofetch, clientUtilsConfig.enabled, true, "{clientGraphql}/{serviceName}/ofetch.ts", placeholders);
+	if (!ofetchPath) return;
+	const serviceDir = dirname(ofetchPath);
+	if (!existsSync(serviceDir)) mkdirSync(serviceDir, { recursive: true });
+	if (existsSync(ofetchPath)) return;
+	writeFileIfNotExists(ofetchPath, nitro.options.framework?.name === "nuxt" ? `// This file is auto-generated once by nitro-graphql for quick start
+// You can modify this file according to your needs
+import type { Requester } from './sdk'
+import { getSdk } from './sdk'
+
+export function createGraphQLClient(endpoint: string): Requester {
+  return async <R>(doc: string, vars?: any): Promise<R> => {
+    const headers = import.meta.server ? useRequestHeaders() : undefined
+
+    const result = await $fetch(endpoint, {
+      method: 'POST',
+      body: { query: doc, variables: vars },
+      headers: {
+        'Content-Type': 'application/json',
+        ...headers,
+      },
+    })
+
+    return result as R
+  }
+}
+
+export const $sdk = getSdk(createGraphQLClient('/api/graphql'))` : `// This file is auto-generated once by nitro-graphql for quick start
+// You can modify this file according to your needs
+import type { Requester } from './sdk'
+import { ofetch } from 'ofetch'
+import { getSdk } from './sdk'
+
+export function createGraphQLClient(endpoint: string): Requester {
+  return async <R>(doc: string, vars?: any): Promise<R> => {
+    const result = await ofetch(endpoint, {
+      method: 'POST',
+      body: { query: doc, variables: vars },
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
+
+    return result as R
+  }
+}
+
+export const $sdk = getSdk(createGraphQLClient('/api/graphql'))`, `${serviceName} ofetch.ts`);
+}
+
+//#endregion
+export { generateMainClientTypes };

package/dist/codegen/external-types.d.mts

@@ -0,0 +1,12 @@
+import { Nitro } from "nitro/types";
+
+//#region src/codegen/external-types.d.ts
+
+/**
+ * Generate types for all external GraphQL services
+ */
+declare function generateExternalServicesTypes(nitro: Nitro, options?: {
+  silent?: boolean;
+}): Promise<void>;
+//#endregion
+export { generateExternalServicesTypes };

package/dist/codegen/external-types.mjs

@@ -0,0 +1,129 @@
+import { LOG_TAG } from "../constants.mjs";
+import { downloadAndSaveSchema, generateExternalClientTypes, loadExternalSchema, loadGraphQLDocuments } from "../utils/client-codegen.mjs";
+import { writeFileIfNotExists } from "../utils/file-generator.mjs";
+import { getClientUtilsConfig, getDefaultPaths, getSdkConfig, getTypesConfig, resolveFilePath, shouldGenerateClientUtils } from "../utils/path-resolver.mjs";
+import consola from "consola";
+import { dirname } from "pathe";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+
+//#region src/codegen/external-types.ts
+consola.withTag(LOG_TAG);
+/**
+* Generate types for all external GraphQL services
+*/
+async function generateExternalServicesTypes(nitro, options = {}) {
+	const externalServices = nitro.options.graphql?.externalServices || [];
+	for (const service of externalServices) try {
+		if (!options.silent) consola.info(`[graphql:${service.name}] Processing external service`);
+		await downloadAndSaveSchema(service, nitro.options.buildDir);
+		const schema = await loadExternalSchema(service, nitro.options.buildDir);
+		if (!schema) {
+			consola.warn(`[graphql:${service.name}] Failed to load schema, skipping`);
+			continue;
+		}
+		const documentPatterns = service.documents || [];
+		let loadedDocs = [];
+		if (documentPatterns.length > 0) try {
+			loadedDocs = await loadGraphQLDocuments(documentPatterns);
+			if (!loadedDocs || loadedDocs.length === 0) {
+				consola.warn(`[graphql:${service.name}] No GraphQL documents found, skipping service generation`);
+				continue;
+			}
+		} catch (error) {
+			consola.warn(`[graphql:${service.name}] No documents found, skipping service generation:`, error);
+			continue;
+		}
+		const types = await generateExternalClientTypes(service, schema, loadedDocs);
+		if (types === false) {
+			consola.warn(`[graphql:${service.name}] Type generation failed`);
+			continue;
+		}
+		const placeholders = {
+			...getDefaultPaths(nitro),
+			serviceName: service.name
+		};
+		const typesConfig = getTypesConfig(nitro);
+		const sdkConfig = getSdkConfig(nitro);
+		const serviceTypesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", placeholders);
+		if (serviceTypesPath) {
+			mkdirSync(dirname(serviceTypesPath), { recursive: true });
+			writeFileSync(serviceTypesPath, types.types, "utf-8");
+			if (!options.silent) consola.success(`[graphql:${service.name}] Generated types at: ${serviceTypesPath}`);
+		}
+		const serviceSdkPath = resolveFilePath(service.paths?.sdk ?? sdkConfig.external, sdkConfig.enabled, true, "{clientGraphql}/{serviceName}/sdk.ts", placeholders);
+		if (serviceSdkPath) {
+			mkdirSync(dirname(serviceSdkPath), { recursive: true });
+			writeFileSync(serviceSdkPath, types.sdk, "utf-8");
+			if (!options.silent) consola.success(`[graphql:${service.name}] Generated SDK at: ${serviceSdkPath}`);
+		}
+		generateExternalOfetchClient(nitro, service, service.endpoint);
+		if (!options.silent) consola.success(`[graphql:${service.name}] External service types generated successfully`);
+	} catch (error) {
+		consola.error(`[graphql:${service.name}] External service generation failed:`, error);
+	}
+}
+/**
+* Generate ofetch client for external service
+*/
+function generateExternalOfetchClient(nitro, service, endpoint) {
+	if (!shouldGenerateClientUtils(nitro)) return;
+	const serviceName = service.name;
+	const placeholders = {
+		...getDefaultPaths(nitro),
+		serviceName
+	};
+	const clientUtilsConfig = getClientUtilsConfig(nitro);
+	const ofetchPath = resolveFilePath(service.paths?.ofetch ?? clientUtilsConfig.ofetch, clientUtilsConfig.enabled, true, "{clientGraphql}/{serviceName}/ofetch.ts", placeholders);
+	if (!ofetchPath) return;
+	const serviceDir = dirname(ofetchPath);
+	if (!existsSync(serviceDir)) mkdirSync(serviceDir, { recursive: true });
+	if (!existsSync(ofetchPath)) {
+		const capitalizedServiceName = serviceName.charAt(0).toUpperCase() + serviceName.slice(1);
+		writeFileIfNotExists(ofetchPath, nitro.options.framework?.name === "nuxt" ? `// This file is auto-generated once by nitro-graphql for quick start
+// You can modify this file according to your needs
+import type { Sdk, Requester } from './sdk'
+import { getSdk } from './sdk'
+
+export function create${capitalizedServiceName}GraphQLClient(endpoint: string = '${endpoint}'): Requester {
+  return async <R>(doc: string, vars?: any): Promise<R> => {
+    const headers = import.meta.server ? useRequestHeaders() : undefined
+
+    const result = await $fetch(endpoint, {
+      method: 'POST',
+      body: { query: doc, variables: vars },
+      headers: {
+        'Content-Type': 'application/json',
+        ...headers,
+      },
+    })
+
+    return result as R
+  }
+}
+
+export const $${serviceName}Sdk: Sdk = getSdk(create${capitalizedServiceName}GraphQLClient())` : `// This file is auto-generated once by nitro-graphql for quick start
+// You can modify this file according to your needs
+import type { Sdk, Requester } from './sdk'
+import { ofetch } from 'ofetch'
+import { getSdk } from './sdk'
+
+export function create${capitalizedServiceName}GraphQLClient(endpoint: string = '${endpoint}'): Requester {
+  return async <R>(doc: string, vars?: any): Promise<R> => {
+    const result = await ofetch(endpoint, {
+      method: 'POST',
+      body: { query: doc, variables: vars },
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
+
+    return result as R
+  }
+}
+
+export const $${serviceName}Sdk: Sdk = getSdk(create${capitalizedServiceName}GraphQLClient())`, `${serviceName} external ofetch.ts`);
+	}
+}
+
+//#endregion
+export { generateExternalServicesTypes };

package/dist/codegen/index.d.mts

@@ -0,0 +1,25 @@
+import { generateMainClientTypes } from "./client-types.mjs";
+import { generateExternalServicesTypes } from "./external-types.mjs";
+import { generateServerTypes } from "./server-types.mjs";
+import { validateNoDuplicateTypes } from "./validation.mjs";
+import { Nitro } from "nitro/types";
+
+//#region src/codegen/index.d.ts
+
+/**
+ * Generate server-side GraphQL resolver types
+ * @deprecated Use generateServerTypes instead
+ */
+declare function serverTypeGeneration(nitro: Nitro, options?: {
+  silent?: boolean;
+}): Promise<void>;
+/**
+ * Generate client-side GraphQL types (main service + external services)
+ * @deprecated Use generateClientTypes instead
+ */
+declare function clientTypeGeneration(nitro: Nitro, options?: {
+  silent?: boolean;
+  isInitial?: boolean;
+}): Promise<void>;
+//#endregion
+export { clientTypeGeneration, serverTypeGeneration };

package/dist/codegen/index.mjs

@@ -0,0 +1,38 @@
+import { LOG_TAG } from "../constants.mjs";
+import { generateMainClientTypes } from "./client-types.mjs";
+import { generateExternalServicesTypes } from "./external-types.mjs";
+import { validateNoDuplicateTypes } from "./validation.mjs";
+import { generateServerTypes } from "./server-types.mjs";
+import consola from "consola";
+
+//#region src/codegen/index.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Generate server-side GraphQL resolver types
+* @deprecated Use generateServerTypes instead
+*/
+async function serverTypeGeneration(nitro, options = {}) {
+	return generateServerTypes(nitro, options);
+}
+/**
+* Generate client-side GraphQL types (main service + external services)
+* @deprecated Use generateClientTypes instead
+*/
+async function clientTypeGeneration(nitro, options = {}) {
+	return generateClientTypes(nitro, options);
+}
+/**
+* Generate client-side GraphQL types
+* Generates types for both main service and external services
+*/
+async function generateClientTypes(nitro, options = {}) {
+	try {
+		if (nitro.scanSchemas && nitro.scanSchemas.length > 0) await generateMainClientTypes(nitro, options);
+		if (nitro.options.graphql?.externalServices?.length) await generateExternalServicesTypes(nitro, options);
+	} catch (error) {
+		logger.error("Client schema generation error:", error);
+	}
+}
+
+//#endregion
+export { clientTypeGeneration, serverTypeGeneration };

package/dist/codegen/server-types.d.mts

@@ -0,0 +1,13 @@
+import { Nitro } from "nitro/types";
+
+//#region src/codegen/server-types.d.ts
+
+/**
+ * Generate server-side GraphQL types
+ * Creates resolver types from GraphQL schemas
+ */
+declare function generateServerTypes(nitro: Nitro, options?: {
+  silent?: boolean;
+}): Promise<void>;
+//#endregion
+export { generateServerTypes };

package/dist/codegen/server-types.mjs

@@ -0,0 +1,76 @@
+import { LOG_TAG } from "../constants.mjs";
+import { getDefaultPaths, getTypesConfig, resolveFilePath, shouldGenerateTypes } from "../utils/path-resolver.mjs";
+import { generateTypes } from "../utils/server-codegen.mjs";
+import { validateNoDuplicateTypes } from "./validation.mjs";
+import consola from "consola";
+import { dirname, resolve } from "pathe";
+import { buildSchema, parse } from "graphql";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { loadFilesSync } from "@graphql-tools/load-files";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+
+//#region src/codegen/server-types.ts
+const logger = consola.withTag(LOG_TAG);
+let buildSubgraphSchema = null;
+/**
+* Load Apollo Federation support if enabled
+*/
+async function loadFederationSupport() {
+	if (buildSubgraphSchema !== null) return buildSubgraphSchema;
+	try {
+		buildSubgraphSchema = (await import("@apollo/subgraph")).buildSubgraphSchema;
+	} catch {
+		buildSubgraphSchema = false;
+	}
+	return buildSubgraphSchema;
+}
+/**
+* Generate server-side GraphQL types
+* Creates resolver types from GraphQL schemas
+*/
+async function generateServerTypes(nitro, options = {}) {
+	try {
+		if (!shouldGenerateTypes(nitro)) {
+			logger.debug("Server type generation is disabled");
+			return;
+		}
+		const schemas = nitro.scanSchemas || [];
+		if (!schemas.length) {
+			if (!options.silent) consola.info("No GraphQL definitions found for server type generation.");
+			return;
+		}
+		const schemaStrings = loadFilesSync(schemas).map((schema$1) => typeof schema$1 === "string" ? schema$1 : schema$1.loc?.source?.body || "").filter(Boolean);
+		if (!validateNoDuplicateTypes(schemas, schemaStrings)) return;
+		const federationEnabled = nitro.options.graphql?.federation?.enabled === true;
+		const mergedSchemas = mergeTypeDefs([schemaStrings.join("\n\n")], {
+			throwOnConflict: true,
+			commentDescriptions: true,
+			sort: true
+		});
+		let schema;
+		if (federationEnabled) {
+			const buildSubgraph = await loadFederationSupport();
+			if (!buildSubgraph) throw new Error("Federation is enabled but @apollo/subgraph is not installed. Run: pnpm add @apollo/subgraph");
+			schema = buildSubgraph([{ typeDefs: parse(mergedSchemas) }]);
+		} else schema = buildSchema(mergedSchemas);
+		const data = await generateTypes(nitro.options.graphql?.framework || "graphql-yoga", schema, nitro.options.graphql ?? {});
+		const printSchema = printSchemaWithDirectives(schema);
+		const schemaPath = resolve(nitro.graphql.buildDir, "schema.graphql");
+		mkdirSync(dirname(schemaPath), { recursive: true });
+		writeFileSync(schemaPath, printSchema, "utf-8");
+		const placeholders = getDefaultPaths(nitro);
+		const typesConfig = getTypesConfig(nitro);
+		const serverTypesPath = resolveFilePath(typesConfig.server, typesConfig.enabled, true, "{typesDir}/nitro-graphql-server.d.ts", placeholders);
+		if (serverTypesPath) {
+			mkdirSync(dirname(serverTypesPath), { recursive: true });
+			writeFileSync(serverTypesPath, data, "utf-8");
+			if (!options.silent) logger.success(`Generated server types at: ${serverTypesPath}`);
+		}
+	} catch (error) {
+		logger.error("Server schema generation error:", error);
+	}
+}
+
+//#endregion
+export { generateServerTypes };

package/dist/codegen/validation.d.mts

@@ -0,0 +1,13 @@
+//#region src/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/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/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/config/defaults.mjs

@@ -0,0 +1,36 @@
+import { DEFAULT_CLIENT_TYPES_PATH, DEFAULT_SERVER_TYPES_PATH, ENDPOINT_GRAPHQL, ENDPOINT_HEALTH } from "../constants.mjs";
+
+//#region src/config/defaults.ts
+/**
+* Default type generation configuration
+*/
+const DEFAULT_TYPES_CONFIG = {
+	server: DEFAULT_SERVER_TYPES_PATH,
+	client: DEFAULT_CLIENT_TYPES_PATH,
+	enabled: true
+};
+/**
+* Default runtime GraphQL configuration
+*/
+const DEFAULT_RUNTIME_CONFIG = {
+	endpoint: {
+		graphql: ENDPOINT_GRAPHQL,
+		healthCheck: ENDPOINT_HEALTH
+	},
+	playground: true
+};
+/**
+* Default TypeScript strict mode setting
+*/
+const DEFAULT_TYPESCRIPT_STRICT = true;
+/**
+* Default watcher persistence setting
+*/
+const DEFAULT_WATCHER_PERSISTENT = true;
+/**
+* Default watcher ignore initial setting
+*/
+const DEFAULT_WATCHER_IGNORE_INITIAL = true;
+
+//#endregion
+export { DEFAULT_RUNTIME_CONFIG, DEFAULT_TYPESCRIPT_STRICT, DEFAULT_TYPES_CONFIG, DEFAULT_WATCHER_IGNORE_INITIAL, DEFAULT_WATCHER_PERSISTENT };