nitro-graphql 2.0.0-beta.31 → 2.0.0-beta.33

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,131 @@
+import { FILE_INDEX_TS, LOG_TAG, SERVICE_DEFAULT } from "../constants.mjs";
+import { generateClientTypes, loadGraphQLDocuments } from "../utils/client-codegen.mjs";
+import { loadFederationSupport } from "../utils/federation.mjs";
+import { writeFileIfNotExists } from "../utils/file-generator.mjs";
+import { generateOfetchTemplate } from "../utils/ofetch-templates.mjs";
+import { getClientUtilsConfig, getDefaultPaths, getSdkConfig, getTypesConfig, resolveFilePath, shouldGenerateClientUtils } from "../utils/path-resolver.mjs";
+import consola from "consola";
+import { dirname, join, resolve } from "pathe";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { buildSchema, parse } from "graphql";
+
+//#region src/codegen/client-types.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* 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, generateOfetchTemplate({
+		serviceName,
+		isNuxt: nitro.options.framework?.name === "nuxt",
+		endpoint: "/api/graphql",
+		isExternal: false
+	}), `${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,88 @@
+import { downloadAndSaveSchema, generateExternalClientTypes, loadExternalSchema, loadGraphQLDocuments } from "../utils/client-codegen.mjs";
+import { writeFileIfNotExists } from "../utils/file-generator.mjs";
+import { generateOfetchTemplate } from "../utils/ofetch-templates.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
+/**
+* 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)) writeFileIfNotExists(ofetchPath, generateOfetchTemplate({
+		serviceName,
+		isNuxt: nitro.options.framework?.name === "nuxt",
+		endpoint,
+		isExternal: true
+	}), `${serviceName} external ofetch.ts`);
+}
+
+//#endregion
+export { generateExternalServicesTypes };

package/dist/codegen/index.d.mts

@@ -0,0 +1,18 @@
+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 client-side GraphQL types
+ * Generates types for both main service and external services
+ */
+declare function generateClientTypes(nitro: Nitro, options?: {
+  silent?: boolean;
+  isInitial?: boolean;
+}): Promise<void>;
+//#endregion
+export { generateClientTypes };

package/dist/codegen/index.mjs

@@ -0,0 +1,24 @@
+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 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 { generateClientTypes };

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,64 @@
+import { LOG_TAG } from "../constants.mjs";
+import { loadFederationSupport } from "../utils/federation.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 { mkdirSync, writeFileSync } from "node:fs";
+import { buildSchema, parse } from "graphql";
+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);
+/**
+* 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 };

package/dist/constants/scalars.mjs

@@ -0,0 +1,27 @@
+import { CurrencyResolver, DateTimeISOResolver, DateTimeResolver, JSONObjectResolver, JSONResolver, NonEmptyStringResolver, UUIDResolver } from "graphql-scalars";
+
+//#region src/constants/scalars.ts
+/**
+* Default GraphQL scalar type definitions
+* Used by both server and client codegen
+*/
+/**
+* Default scalar type mappings for GraphQL codegen
+* These scalars are commonly used and have proper TypeScript type mappings
+*/
+const DEFAULT_GRAPHQL_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"
+	}
+};
+
+//#endregion
+export { DEFAULT_GRAPHQL_SCALARS };

package/dist/constants.mjs

@@ -0,0 +1,106 @@
+//#region src/constants.ts
+/**
+* Constants and magic strings used throughout nitro-graphql
+* Centralizing these values prevents typos and makes refactoring easier
+*/
+/**
+* GraphQL schema file extensions
+*/
+const GRAPHQL_EXTENSIONS = [".graphql", ".gql"];
+/**
+* Resolver file extensions
+*/
+const RESOLVER_EXTENSIONS = [".resolver.ts", ".resolver.js"];
+/**
+* Directive file extensions
+*/
+const DIRECTIVE_EXTENSIONS = [".directive.ts", ".directive.js"];
+/**
+* Combined pattern for glob scanning
+*/
+const GLOB_SCAN_PATTERN = "**/*.{graphql,gql,js,mjs,cjs,ts,mts,cts,tsx,jsx}";
+/**
+* Framework names
+*/
+const FRAMEWORK_NUXT = "nuxt";
+const FRAMEWORK_NITRO = "nitro";
+/**
+* Default directory names for GraphQL files
+*/
+const DIR_SERVER_GRAPHQL = "server/graphql";
+/**
+* Windows-compatible server GraphQL directory
+*/
+const DIR_SERVER_GRAPHQL_WIN = "server\\graphql";
+/**
+* Default GraphQL endpoint paths
+*/
+const ENDPOINT_GRAPHQL = "/api/graphql";
+const ENDPOINT_HEALTH = "/api/graphql/health";
+const ENDPOINT_DEBUG = "/_nitro/graphql/debug";
+/**
+* Configuration and scaffold file names
+*/
+const FILE_GRAPHQL_CONFIG = "graphql.config.ts";
+const FILE_SCHEMA_TS = "schema.ts";
+const FILE_CONFIG_TS = "config.ts";
+const FILE_CONTEXT_DTS = "context.d.ts";
+const FILE_CONTEXT_TS = "context.ts";
+const FILE_INDEX_TS = "index.ts";
+/**
+* Rollup/Rolldown chunk output paths
+*/
+const CHUNK_PATH_GRAPHQL = "chunks/graphql/[name].mjs";
+const CHUNK_PATH_UNKNOWN = "chunks/_/[name].mjs";
+/**
+* Default chunk names
+*/
+const CHUNK_NAME_SCHEMAS = "schemas";
+const CHUNK_NAME_RESOLVERS = "resolvers";
+/**
+* Valid define function names for resolver exports
+*/
+const DEFINE_FUNCTIONS = [
+	"defineResolver",
+	"defineQuery",
+	"defineMutation",
+	"defineField",
+	"defineSubscription",
+	"defineDirective"
+];
+/**
+* Built-in GraphQL scalar types (should not be flagged as duplicates)
+*/
+const BUILTIN_SCALARS = [
+	"String",
+	"Int",
+	"Float",
+	"Boolean",
+	"ID",
+	"DateTime",
+	"JSON"
+];
+/**
+* Supported HTTP methods for GraphQL endpoints
+*/
+const GRAPHQL_HTTP_METHODS = [
+	"GET",
+	"POST",
+	"OPTIONS"
+];
+/**
+* Default paths for type generation (relative to buildDir)
+*/
+const DEFAULT_SERVER_TYPES_PATH = ".graphql/nitro-graphql-server.d.ts";
+const DEFAULT_CLIENT_TYPES_PATH = ".graphql/nitro-graphql-client.d.ts";
+/**
+* Logger tag for nitro-graphql module
+*/
+const LOG_TAG = "nitro-graphql";
+/**
+* Default service directory name for main service
+*/
+const SERVICE_DEFAULT = "default";
+
+//#endregion
+export { BUILTIN_SCALARS, CHUNK_NAME_RESOLVERS, CHUNK_NAME_SCHEMAS, CHUNK_PATH_GRAPHQL, CHUNK_PATH_UNKNOWN, DEFAULT_CLIENT_TYPES_PATH, DEFAULT_SERVER_TYPES_PATH, DEFINE_FUNCTIONS, DIRECTIVE_EXTENSIONS, DIR_SERVER_GRAPHQL, DIR_SERVER_GRAPHQL_WIN, ENDPOINT_DEBUG, ENDPOINT_GRAPHQL, ENDPOINT_HEALTH, FILE_CONFIG_TS, FILE_CONTEXT_DTS, FILE_CONTEXT_TS, FILE_GRAPHQL_CONFIG, FILE_INDEX_TS, FILE_SCHEMA_TS, FRAMEWORK_NITRO, FRAMEWORK_NUXT, GLOB_SCAN_PATTERN, GRAPHQL_EXTENSIONS, GRAPHQL_HTTP_METHODS, LOG_TAG, RESOLVER_EXTENSIONS, SERVICE_DEFAULT };

package/dist/ecosystem/nuxt.mjs

@@ -1,6 +1,6 @@
 import { getDefaultPaths, getTypesConfig, resolveFilePath } from "../utils/path-resolver.mjs";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join, relative, resolve } from "pathe";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { defineNuxtModule, getLayerDirectories } from "@nuxt/kit";
 
 //#region src/ecosystem/nuxt.ts
@@ -46,8 +46,8 @@ var nuxt_default = defineNuxtModule({
 				if (externalTypesPath) {
 					const relativePath = relativeWithDot(tsconfigDir, externalTypesPath);
 					options.references.push({ path: relativePath });
-					options.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [relativePath];
-					options.tsConfig.include.push(relativePath);
+					if (options.tsConfig.compilerOptions) options.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [relativePath];
+					if (options.tsConfig.include) options.tsConfig.include.push(relativePath);
 				}
 			}
 		});