nitro-graphql 1.4.4 → 1.5.1

package/dist/utils/client-codegen.js

@@ -101,15 +101,13 @@ async function downloadAndSaveSchema(service, buildDir) {
 		if (downloadMode === "always") {
 			shouldDownload = true;
 			if (fileExists && hasUrlSchemas) try {
-				const remoteSchema = loadSchemaSync(schemas.filter(isUrl), {
+				const remoteSchemaString = printSchemaWithDirectives(loadSchemaSync(schemas.filter(isUrl), {
 					loaders: [new UrlLoader()],
 					...Object.keys(headers).length > 0 && { headers }
-				});
-				const remoteSchemaString = printSchemaWithDirectives(remoteSchema);
+				}));
 				const remoteHash = createHash("md5").update(remoteSchemaString).digest("hex");
 				const localSchemaString = readFileSync(schemaFilePath, "utf-8");
-				const localHash = createHash("md5").update(localSchemaString).digest("hex");
-				if (remoteHash === localHash) {
+				if (remoteHash === createHash("md5").update(localSchemaString).digest("hex")) {
 					shouldDownload = false;
 					consola$1.info(`[graphql:${service.name}] Schema is up-to-date, using cached version`);
 				}
@@ -134,24 +132,21 @@ async function downloadAndSaveSchema(service, buildDir) {
 		} else if (downloadMode === true || downloadMode === "once") shouldDownload = !fileExists;
 		if (shouldDownload) {
 			if (hasUrlSchemas && hasLocalSchemas) {
-				const schema = loadSchemaSync(schemas, {
+				const schemaString = printSchemaWithDirectives(loadSchemaSync(schemas, {
 					loaders: [new GraphQLFileLoader(), new UrlLoader()],
 					...Object.keys(headers).length > 0 && { headers }
-				});
-				const schemaString = printSchemaWithDirectives(schema);
+				}));
 				mkdirSync(dirname(schemaFilePath), { recursive: true });
 				writeFileSync(schemaFilePath, schemaString, "utf-8");
 			} else if (hasUrlSchemas) {
-				const schema = loadSchemaSync(schemas, {
+				const schemaString = printSchemaWithDirectives(loadSchemaSync(schemas, {
 					loaders: [new UrlLoader()],
 					...Object.keys(headers).length > 0 && { headers }
-				});
-				const schemaString = printSchemaWithDirectives(schema);
+				}));
 				mkdirSync(dirname(schemaFilePath), { recursive: true });
 				writeFileSync(schemaFilePath, schemaString, "utf-8");
 			} else if (hasLocalSchemas) {
-				const schema = loadSchemaSync(schemas, { loaders: [new GraphQLFileLoader()] });
-				const schemaString = printSchemaWithDirectives(schema);
+				const schemaString = printSchemaWithDirectives(loadSchemaSync(schemas, { loaders: [new GraphQLFileLoader()] }));
 				mkdirSync(dirname(schemaFilePath), { recursive: true });
 				writeFileSync(schemaFilePath, schemaString, "utf-8");
 			}
@@ -176,7 +171,7 @@ async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, ou
 		return false;
 	}
 	const serviceLabel = serviceName ? `:${serviceName}` : "";
-	const defaultConfig = {
+	const mergedConfig = defu$1({
 		emitLegacyCommonJSImports: false,
 		useTypeImports: true,
 		enumsAsTypes: true,
@@ -200,8 +195,7 @@ async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, ou
 				output: "File"
 			}
 		}
-	};
-	const mergedConfig = defu$1(defaultConfig, config);
+	}, config);
 	const mergedSdkConfig = defu$1(mergedConfig, sdkConfig);
 	try {
 		if (docs.length === 0) return {
@@ -271,15 +265,14 @@ export function getSdk(requester: Requester): Sdk {
 				typescriptGenericSdk: { plugin: plugin$1 }
 			}
 		});
-		const sdkContent = (await Promise.all(sdkOutput.map(async (config$1) => {
-			return {
-				file: config$1.filename,
-				content: await codegen(config$1)
-			};
-		})))[0]?.content || "";
 		return {
 			types: output,
-			sdk: sdkContent
+			sdk: (await Promise.all(sdkOutput.map(async (config$1) => {
+				return {
+					file: config$1.filename,
+					content: await codegen(config$1)
+				};
+			})))[0]?.content || ""
 		};
 	} catch (error) {
 		consola$1.warn(`[graphql${serviceLabel}] Client type generation failed:`, error);
@@ -290,9 +283,7 @@ export function getSdk(requester: Requester): Sdk {
 * Generate client types for external GraphQL service
 */
 async function generateExternalClientTypes(service, schema, docs) {
-	const config = service.codegen?.client || {};
-	const sdkConfig = service.codegen?.clientSDK || {};
-	return generateClientTypes(schema, docs, config, sdkConfig, void 0, service.name);
+	return generateClientTypes(schema, docs, service.codegen?.client || {}, service.codegen?.clientSDK || {}, void 0, service.name);
 }
 
 //#endregion

package/dist/utils/file-generator.d.ts

@@ -0,0 +1,37 @@
+import { Nitro } from "nitropack/types";
+
+//#region src/utils/file-generator.d.ts
+
+/**
+ * Safely write a file to disk, creating parent directories if needed
+ */
+declare function writeFile(filePath: string, content: string, description?: string): void;
+/**
+ * Write a file only if it doesn't already exist
+ * Returns true if file was created, false if it already existed
+ */
+declare function writeFileIfNotExists(filePath: string, content: string, description?: string): boolean;
+/**
+ * Write a file and always overwrite (used for generated files like SDK)
+ * This is for files that are auto-generated and should be updated on every build
+ */
+declare function writeGeneratedFile(filePath: string, content: string, description?: string): void;
+/**
+ * Check if a path is configured and should be generated
+ * Returns the resolved path if should generate, null otherwise
+ */
+declare function getGenerationPath(resolvedPath: string | null, description?: string): string | null;
+/**
+ * Log skipped file generation (helpful for debugging library mode)
+ */
+declare function logSkipped(fileName: string, reason?: string): void;
+/**
+ * Log generated file path
+ */
+declare function logGenerated(fileName: string, path: string): void;
+/**
+ * Validate that a Nitro instance has the required GraphQL configuration
+ */
+declare function validateGraphQLConfig(nitro: Nitro): boolean;
+//#endregion
+export { getGenerationPath, logGenerated, logSkipped, validateGraphQLConfig, writeFile, writeFileIfNotExists, writeGeneratedFile };

package/dist/utils/file-generator.js

@@ -0,0 +1,72 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import consola from "consola";
+import { dirname } from "pathe";
+
+//#region src/utils/file-generator.ts
+/**
+* Safely write a file to disk, creating parent directories if needed
+*/
+function writeFile(filePath, content, description) {
+	try {
+		const dir = dirname(filePath);
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		writeFileSync(filePath, content, "utf-8");
+		if (description) consola.success(`[nitro-graphql] Generated: ${description}`);
+	} catch (error) {
+		consola.error(`[nitro-graphql] Failed to write file: ${filePath}`, error);
+		throw error;
+	}
+}
+/**
+* Write a file only if it doesn't already exist
+* Returns true if file was created, false if it already existed
+*/
+function writeFileIfNotExists(filePath, content, description) {
+	if (existsSync(filePath)) return false;
+	writeFile(filePath, content, description);
+	return true;
+}
+/**
+* Write a file and always overwrite (used for generated files like SDK)
+* This is for files that are auto-generated and should be updated on every build
+*/
+function writeGeneratedFile(filePath, content, description) {
+	writeFile(filePath, content, description);
+}
+/**
+* Check if a path is configured and should be generated
+* Returns the resolved path if should generate, null otherwise
+*/
+function getGenerationPath(resolvedPath, description) {
+	if (!resolvedPath) {
+		if (description) consola.debug(`[nitro-graphql] Skipping generation: ${description} (disabled in config)`);
+		return null;
+	}
+	return resolvedPath;
+}
+/**
+* Log skipped file generation (helpful for debugging library mode)
+*/
+function logSkipped(fileName, reason) {
+	const message = reason ? `Skipped ${fileName}: ${reason}` : `Skipped ${fileName}`;
+	consola.debug(`[nitro-graphql] ${message}`);
+}
+/**
+* Log generated file path
+*/
+function logGenerated(fileName, path) {
+	consola.info(`[nitro-graphql] Generated ${fileName} at: ${path}`);
+}
+/**
+* Validate that a Nitro instance has the required GraphQL configuration
+*/
+function validateGraphQLConfig(nitro) {
+	if (!nitro.options.graphql?.framework) {
+		consola.warn("[nitro-graphql] No GraphQL framework specified. Some features may not work correctly.");
+		return false;
+	}
+	return true;
+}
+
+//#endregion
+export { getGenerationPath, logGenerated, logSkipped, validateGraphQLConfig, writeFile, writeFileIfNotExists, writeGeneratedFile };

package/dist/utils/index.js

@@ -49,50 +49,78 @@ async function scanGraphql(nitro) {
 async function scanResolvers(nitro) {
 	const files = await scanFiles(nitro, "graphql", "**/*.resolver.{ts,js}");
 	const exportName = [];
-	for (const file of files) {
+	const VALID_DEFINE_FUNCTIONS = [
+		"defineResolver",
+		"defineQuery",
+		"defineMutation",
+		"defineType",
+		"defineSubscription",
+		"defineDirective"
+	];
+	for (const file of files) try {
 		const fileContent = await readFile(file.fullPath, "utf-8");
 		const parsed = await parseAsync(file.fullPath, fileContent);
 		const exports = {
 			imports: [],
 			specifier: file.fullPath
 		};
-		for (const node of parsed.program.body) if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "VariableDeclaration") {
-			for (const decl of node.declaration.declarations) if (decl.type === "VariableDeclarator" && decl.init && decl.id.type === "Identifier") {
-				if (decl.init && decl.init.type === "CallExpression") {
-					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineResolver") exports.imports.push({
-						name: decl.id.name,
-						type: "resolver",
-						as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
-					});
-					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineQuery") exports.imports.push({
-						name: decl.id.name,
-						type: "query",
-						as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
-					});
-					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineMutation") exports.imports.push({
-						name: decl.id.name,
-						type: "mutation",
-						as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
-					});
-					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineType") exports.imports.push({
-						name: decl.id.name,
-						type: "type",
-						as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
-					});
-					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineSubscription") exports.imports.push({
-						name: decl.id.name,
-						type: "subscription",
-						as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
-					});
-					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineDirective") exports.imports.push({
-						name: decl.id.name,
-						type: "directive",
-						as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
-					});
+		let hasDefaultExport = false;
+		let hasNamedExport = false;
+		const namedExports = [];
+		for (const node of parsed.program.body) {
+			if (node.type === "ExportDefaultDeclaration") hasDefaultExport = true;
+			if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "VariableDeclaration") {
+				for (const decl of node.declaration.declarations) if (decl.type === "VariableDeclarator" && decl.init && decl.id.type === "Identifier") {
+					hasNamedExport = true;
+					namedExports.push(decl.id.name);
+					if (decl.init && decl.init.type === "CallExpression") {
+						if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineResolver") exports.imports.push({
+							name: decl.id.name,
+							type: "resolver",
+							as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
+						});
+						if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineQuery") exports.imports.push({
+							name: decl.id.name,
+							type: "query",
+							as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
+						});
+						if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineMutation") exports.imports.push({
+							name: decl.id.name,
+							type: "mutation",
+							as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
+						});
+						if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineType") exports.imports.push({
+							name: decl.id.name,
+							type: "type",
+							as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
+						});
+						if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineSubscription") exports.imports.push({
+							name: decl.id.name,
+							type: "subscription",
+							as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
+						});
+						if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineDirective") exports.imports.push({
+							name: decl.id.name,
+							type: "directive",
+							as: `_${hash(decl.id.name + file.fullPath).replace(/-/g, "").slice(0, 6)}`
+						});
+					}
 				}
 			}
 		}
+		if (nitro.options.dev) {
+			const relPath = relative(nitro.options.rootDir, file.fullPath);
+			if (hasDefaultExport && !hasNamedExport) nitro.logger.warn(`[nitro-graphql] ${relPath}: Using default export instead of named export. Resolvers must use named exports like "export const myResolver = defineQuery(...)". Default exports are not detected.`);
+			if (exports.imports.length === 0 && hasNamedExport) {
+				const validFunctions = VALID_DEFINE_FUNCTIONS.join(", ");
+				nitro.logger.warn(`[nitro-graphql] ${relPath}: File has named exports [${namedExports.join(", ")}] but none use the required define functions (${validFunctions}). Exports will not be registered.`);
+			}
+			if (!hasDefaultExport && !hasNamedExport) nitro.logger.warn(`[nitro-graphql] ${relPath}: No exports found. Resolver files must export resolvers using defineResolver, defineQuery, defineMutation, etc.`);
+		}
 		if (exports.imports.length > 0) exportName.push(exports);
+	} catch (error) {
+		const relPath = relative(nitro.options.rootDir, file.fullPath);
+		nitro.logger.error(`[nitro-graphql] Failed to parse resolver file ${relPath}:`, error);
 	}
 	return exportName;
 }
@@ -143,9 +171,7 @@ async function scanDocs(nitro) {
 		const relativePath = f.path;
 		for (const pattern of externalPatterns) {
 			const clientDirPattern = `${nitro.graphql.dir.client}/`;
-			const patternDir = pattern.replace(/* @__PURE__ */ new RegExp(`^${clientDirPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`), "").split("/")[0];
-			const fileDir = relativePath.split("/")[0];
-			if (patternDir === fileDir) return false;
+			if (pattern.replace(/* @__PURE__ */ new RegExp(`^${clientDirPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`), "").split("/")[0] === relativePath.split("/")[0]) return false;
 		}
 		return true;
 	}).map((f) => f.fullPath);

package/dist/utils/path-resolver.d.ts

@@ -0,0 +1,70 @@
+import { ClientUtilsConfig, FileGenerationConfig, ScaffoldConfig, SdkConfig, TypesConfig } from "../types/index.js";
+import { Nitro } from "nitropack/types";
+
+//#region src/utils/path-resolver.d.ts
+
+/**
+ * Placeholder values for path resolution
+ */
+interface PathPlaceholders {
+  serviceName?: string;
+  buildDir: string;
+  rootDir: string;
+  framework: 'nuxt' | 'nitro';
+  typesDir: string;
+  serverGraphql: string;
+  clientGraphql: string;
+}
+/**
+ * Replace placeholders in a path string
+ * Supports: {serviceName}, {buildDir}, {rootDir}, {framework}, {typesDir}, {serverGraphql}, {clientGraphql}
+ */
+declare function replacePlaceholders(path: string, placeholders: PathPlaceholders): string;
+/**
+ * Get default paths based on framework and user configuration
+ */
+declare function getDefaultPaths(nitro: Nitro): Required<PathPlaceholders>;
+/**
+ * Check if a file should be generated based on config
+ * Returns: true if should generate, false if should skip
+ */
+declare function shouldGenerateFile(config: FileGenerationConfig | undefined, categoryEnabled: boolean | undefined, topLevelEnabled: boolean): boolean;
+/**
+ * Resolve the file path based on configuration
+ * Returns: resolved absolute path or null if file should not be generated
+ */
+declare function resolveFilePath(config: FileGenerationConfig | undefined, categoryEnabled: boolean | undefined, topLevelEnabled: boolean, defaultPath: string, placeholders: PathPlaceholders): string | null;
+/**
+ * Check if scaffold files should be generated (category-level check)
+ */
+declare function shouldGenerateScaffold(nitro: Nitro): boolean;
+/**
+ * Get scaffold configuration (handles false case)
+ */
+declare function getScaffoldConfig(nitro: Nitro): ScaffoldConfig;
+/**
+ * Check if client utilities should be generated (category-level check)
+ */
+declare function shouldGenerateClientUtils(nitro: Nitro): boolean;
+/**
+ * Get client utilities configuration (handles false case)
+ */
+declare function getClientUtilsConfig(nitro: Nitro): ClientUtilsConfig;
+/**
+ * Check if SDK files should be generated (category-level check)
+ */
+declare function shouldGenerateSDK(nitro: Nitro): boolean;
+/**
+ * Get SDK configuration (handles false case)
+ */
+declare function getSdkConfig(nitro: Nitro): SdkConfig;
+/**
+ * Check if type files should be generated (category-level check)
+ */
+declare function shouldGenerateTypes(nitro: Nitro): boolean;
+/**
+ * Get types configuration (handles false case)
+ */
+declare function getTypesConfig(nitro: Nitro): TypesConfig;
+//#endregion
+export { PathPlaceholders, getClientUtilsConfig, getDefaultPaths, getScaffoldConfig, getSdkConfig, getTypesConfig, replacePlaceholders, resolveFilePath, shouldGenerateClientUtils, shouldGenerateFile, shouldGenerateSDK, shouldGenerateScaffold, shouldGenerateTypes };

package/dist/utils/path-resolver.js

@@ -0,0 +1,127 @@
+import { resolve } from "pathe";
+
+//#region src/utils/path-resolver.ts
+/**
+* Replace placeholders in a path string
+* Supports: {serviceName}, {buildDir}, {rootDir}, {framework}, {typesDir}, {serverGraphql}, {clientGraphql}
+*/
+function replacePlaceholders(path, placeholders) {
+	return path.replace(/\{serviceName\}/g, placeholders.serviceName || "default").replace(/\{buildDir\}/g, placeholders.buildDir).replace(/\{rootDir\}/g, placeholders.rootDir).replace(/\{framework\}/g, placeholders.framework).replace(/\{typesDir\}/g, placeholders.typesDir).replace(/\{serverGraphql\}/g, placeholders.serverGraphql).replace(/\{clientGraphql\}/g, placeholders.clientGraphql);
+}
+/**
+* Get default paths based on framework and user configuration
+*/
+function getDefaultPaths(nitro) {
+	const isNuxt = nitro.options.framework?.name === "nuxt";
+	const rootDir = nitro.options.rootDir;
+	const buildDir = nitro.options.buildDir;
+	const pathsConfig = nitro.options.graphql?.paths || {};
+	const defaultServerGraphql = pathsConfig.serverGraphql || resolve(rootDir, "server", "graphql");
+	const defaultClientGraphql = pathsConfig.clientGraphql || resolve(rootDir, isNuxt ? "app/graphql" : "graphql");
+	const defaultBuildDir = pathsConfig.buildDir || buildDir;
+	const defaultTypesDir = pathsConfig.typesDir || resolve(defaultBuildDir, "types");
+	return {
+		serviceName: "default",
+		buildDir: defaultBuildDir,
+		rootDir,
+		framework: isNuxt ? "nuxt" : "nitro",
+		typesDir: defaultTypesDir,
+		serverGraphql: defaultServerGraphql,
+		clientGraphql: defaultClientGraphql
+	};
+}
+/**
+* Check if a file should be generated based on config
+* Returns: true if should generate, false if should skip
+*/
+function shouldGenerateFile(config, categoryEnabled, topLevelEnabled) {
+	if (config === false) return false;
+	if (config === true || typeof config === "string") return true;
+	if (categoryEnabled === false) return false;
+	if (categoryEnabled === true) return true;
+	return topLevelEnabled;
+}
+/**
+* Resolve the file path based on configuration
+* Returns: resolved absolute path or null if file should not be generated
+*/
+function resolveFilePath(config, categoryEnabled, topLevelEnabled, defaultPath, placeholders) {
+	if (!shouldGenerateFile(config, categoryEnabled, topLevelEnabled)) return null;
+	if (typeof config === "string") {
+		const customPath = replacePlaceholders(config, placeholders);
+		return resolve(placeholders.rootDir, customPath);
+	}
+	const resolvedDefault = replacePlaceholders(defaultPath, placeholders);
+	return resolve(placeholders.rootDir, resolvedDefault);
+}
+/**
+* Check if scaffold files should be generated (category-level check)
+*/
+function shouldGenerateScaffold(nitro) {
+	const scaffoldConfig = nitro.options.graphql?.scaffold;
+	if (scaffoldConfig === false) return false;
+	if (scaffoldConfig && scaffoldConfig.enabled === false) return false;
+	return true;
+}
+/**
+* Get scaffold configuration (handles false case)
+*/
+function getScaffoldConfig(nitro) {
+	const scaffoldConfig = nitro.options.graphql?.scaffold;
+	if (scaffoldConfig === false) return { enabled: false };
+	return scaffoldConfig || {};
+}
+/**
+* Check if client utilities should be generated (category-level check)
+*/
+function shouldGenerateClientUtils(nitro) {
+	const clientUtilsConfig = nitro.options.graphql?.clientUtils;
+	if (clientUtilsConfig === false) return false;
+	if (clientUtilsConfig && clientUtilsConfig.enabled === false) return false;
+	return nitro.options.framework?.name === "nuxt";
+}
+/**
+* Get client utilities configuration (handles false case)
+*/
+function getClientUtilsConfig(nitro) {
+	const clientUtilsConfig = nitro.options.graphql?.clientUtils;
+	if (clientUtilsConfig === false) return { enabled: false };
+	return clientUtilsConfig || {};
+}
+/**
+* Check if SDK files should be generated (category-level check)
+*/
+function shouldGenerateSDK(nitro) {
+	const sdkConfig = nitro.options.graphql?.sdk;
+	if (sdkConfig === false) return false;
+	if (sdkConfig && sdkConfig.enabled === false) return false;
+	return true;
+}
+/**
+* Get SDK configuration (handles false case)
+*/
+function getSdkConfig(nitro) {
+	const sdkConfig = nitro.options.graphql?.sdk;
+	if (sdkConfig === false) return { enabled: false };
+	return sdkConfig || {};
+}
+/**
+* Check if type files should be generated (category-level check)
+*/
+function shouldGenerateTypes(nitro) {
+	const typesConfig = nitro.options.graphql?.types;
+	if (typesConfig === false) return false;
+	if (typesConfig && typesConfig.enabled === false) return false;
+	return true;
+}
+/**
+* Get types configuration (handles false case)
+*/
+function getTypesConfig(nitro) {
+	const typesConfig = nitro.options.graphql?.types;
+	if (typesConfig === false) return { enabled: false };
+	return typesConfig || {};
+}
+
+//#endregion
+export { getClientUtilsConfig, getDefaultPaths, getScaffoldConfig, getSdkConfig, getTypesConfig, replacePlaceholders, resolveFilePath, shouldGenerateClientUtils, shouldGenerateFile, shouldGenerateSDK, shouldGenerateScaffold, shouldGenerateTypes };

package/dist/utils/server-codegen.js

@@ -21,7 +21,7 @@ function pluginContent(_schema, _documents, _config, _info) {
 	};
 }
 async function generateTypes(selectFremework, schema, config = {}, outputPath) {
-	const defaultConfig = {
+	const mergedConfig = defu$1({
 		scalars: {
 			DateTime: DateTimeResolver.extensions.codegenScalarType,
 			DateTimeISO: DateTimeISOResolver.extensions.codegenScalarType,
@@ -43,8 +43,7 @@ async function generateTypes(selectFremework, schema, config = {}, outputPath) {
 		declarationKind: "interface",
 		enumsAsTypes: true,
 		...config.federation?.enabled && { federation: true }
-	};
-	const mergedConfig = defu$1(defaultConfig, config.codegen?.server);
+	}, config.codegen?.server);
 	return await codegen({
 		filename: outputPath || "types.generated.ts",
 		schema: parse(printSchemaWithDirectives(schema)),