nitro-graphql 2.0.0-beta.37 → 2.0.0-beta.38

package/dist/constants.mjs

@@ -1,106 +0,0 @@
-//#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/graphql/index.d.mts

@@ -1,5 +0,0 @@
-//#region src/graphql/index.d.ts
-interface StandardSchemaV1 extends Record<string, any> {}
-interface ResolversTypes extends Record<string, any> {}
-//#endregion
-export { ResolversTypes, StandardSchemaV1 };

package/dist/setup/graphql-scanner.mjs

@@ -1,25 +0,0 @@
-import { generateDirectiveSchemas } from "../utils/directive-parser.mjs";
-import { scanDirectives } from "../utils/scanning/directives.mjs";
-import { scanDocuments } from "../utils/scanning/documents.mjs";
-import { scanResolvers } from "../utils/scanning/resolvers.mjs";
-import { scanSchemas } from "../utils/scanning/schemas.mjs";
-
-//#region src/setup/graphql-scanner.ts
-/**
-* Scan all GraphQL files and update Nitro state
-* Used by both initial setup and dev:start hook
-*/
-async function scanAllGraphQLFiles(nitro) {
-	const directives = await scanDirectives(nitro);
-	nitro.scanDirectives = directives;
-	if (!nitro.scanSchemas) nitro.scanSchemas = [];
-	const directivesPath = await generateDirectiveSchemas(nitro, directives);
-	const schemas = await scanSchemas(nitro);
-	if (directivesPath && !schemas.includes(directivesPath)) schemas.push(directivesPath);
-	nitro.scanSchemas = schemas;
-	nitro.scanDocuments = await scanDocuments(nitro);
-	nitro.scanResolvers = await scanResolvers(nitro);
-}
-
-//#endregion
-export { scanAllGraphQLFiles };

package/dist/setup/scaffold-generator.mjs

@@ -1,109 +0,0 @@
-import { FILE_CONFIG_TS, FILE_CONTEXT_DTS, FILE_CONTEXT_TS, FILE_GRAPHQL_CONFIG, FILE_SCHEMA_TS, LOG_TAG } from "../constants.mjs";
-import { writeFileIfNotExists } from "../utils/file-generator.mjs";
-import { getDefaultPaths, getScaffoldConfig, resolveFilePath, shouldGenerateScaffold } from "../utils/path-resolver.mjs";
-import { relativeWithDot } from "../utils/imports.mjs";
-import consola from "consola";
-import { join, resolve } from "pathe";
-import { existsSync, mkdirSync } from "node:fs";
-
-//#region src/setup/scaffold-generator.ts
-const logger = consola.withTag(LOG_TAG);
-/**
-* Generate all scaffold files based on configuration
-* Can be disabled via: scaffold: false or scaffold.enabled: false
-*/
-function generateScaffoldFiles(nitro) {
-	if (!shouldGenerateScaffold(nitro)) {
-		logger.info("Scaffold file generation is disabled (library mode)");
-		return;
-	}
-	const placeholders = getDefaultPaths(nitro);
-	const scaffoldConfig = getScaffoldConfig(nitro);
-	generateGraphQLConfig(nitro, scaffoldConfig, placeholders);
-	generateServerScaffoldFiles(nitro, scaffoldConfig, placeholders);
-	checkOldContextFile(nitro);
-}
-/**
-* Generate graphql.config.ts for IDE tooling support
-*/
-function generateGraphQLConfig(nitro, scaffoldConfig, placeholders) {
-	const graphqlConfigPath = resolveFilePath(scaffoldConfig.graphqlConfig, scaffoldConfig.enabled, true, FILE_GRAPHQL_CONFIG, placeholders);
-	if (!graphqlConfigPath) return;
-	writeFileIfNotExists(graphqlConfigPath, `import type { IGraphQLConfig } from 'graphql-config'
-
-export default <IGraphQLConfig> {
-    projects: {
-      default: {
-        schema: [
-          '${relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.buildDir, "schema.graphql"))}',
-        ],
-        documents: [
-          '${relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.clientDir, "**/*.{graphql,js,ts,jsx,tsx}"))}',
-        ],
-      },
-    },
-}`, FILE_GRAPHQL_CONFIG);
-}
-/**
-* Generate server-side scaffold files (schema.ts, config.ts, context.d.ts)
-*/
-function generateServerScaffoldFiles(nitro, scaffoldConfig, placeholders) {
-	const serverSchemaPath = resolveFilePath(scaffoldConfig.serverSchema, scaffoldConfig.enabled, true, "{serverGraphql}/schema.ts", placeholders);
-	const serverConfigPath = resolveFilePath(scaffoldConfig.serverConfig, scaffoldConfig.enabled, true, "{serverGraphql}/config.ts", placeholders);
-	const serverContextPath = resolveFilePath(scaffoldConfig.serverContext, scaffoldConfig.enabled, true, "{serverGraphql}/context.d.ts", placeholders);
-	if (serverSchemaPath || serverConfigPath || serverContextPath) {
-		if (!existsSync(nitro.graphql.serverDir)) mkdirSync(nitro.graphql.serverDir, { recursive: true });
-	}
-	if (serverSchemaPath) writeFileIfNotExists(serverSchemaPath, `export default defineSchema({
-
-})
-`, `server ${FILE_SCHEMA_TS}`);
-	if (serverConfigPath) writeFileIfNotExists(serverConfigPath, `// Example GraphQL config file please change it to your needs
-// import * as tables from '../drizzle/schema/index'
-// import { useDatabase } from '../utils/useDb'
-import { defineGraphQLConfig } from 'nitro-graphql/define'
-
-export default defineGraphQLConfig({
-// graphql-yoga example config
-// context: () => {
-//   return {
-//     context: {
-//       useDatabase,
-//       tables,
-//     },
-//   }
-// },
-})
-`, `server ${FILE_CONFIG_TS}`);
-	if (serverContextPath) writeFileIfNotExists(serverContextPath, `// Example context definition - please change it to your needs
-// import type { Database } from '../utils/useDb'
-
-declare module 'nitro/h3' {
-  interface H3EventContext {
-    // Add your custom context properties here
-    // useDatabase: () => Database
-    // tables: typeof import('../drizzle/schema')
-    // auth?: {
-    //   user?: {
-    //     id: string
-    //     role: 'admin' | 'user'
-    //   }
-    // }
-  }
-}
-
-export {}
-`, `server ${FILE_CONTEXT_DTS}`);
-}
-/**
-* Check for old context.ts file and warn users to migrate to context.d.ts
-*/
-function checkOldContextFile(nitro) {
-	if (existsSync(join(nitro.graphql.serverDir, FILE_CONTEXT_TS))) {
-		logger.warn(`Found ${FILE_CONTEXT_TS} file. Please rename it to ${FILE_CONTEXT_DTS} for type-only definitions.`);
-		logger.info(`The context file should now be ${FILE_CONTEXT_DTS} instead of ${FILE_CONTEXT_TS}`);
-	}
-}
-
-//#endregion
-export { generateScaffoldFiles };

package/dist/types/standard-schema.d.mts

@@ -1,59 +0,0 @@
-//#region src/types/standard-schema.d.ts
-/** The Standard Schema interface. */
-interface StandardSchemaV1<Input = unknown, Output = Input> {
-  /** The Standard Schema properties. */
-  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
-}
-declare namespace StandardSchemaV1 {
-  /** The Standard Schema properties interface. */
-  export interface Props<Input = unknown, Output = Input> {
-    /** The version number of the standard. */
-    readonly version: 1;
-    /** The vendor name of the schema library. */
-    readonly vendor: string;
-    /** Validates unknown input values. */
-    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-    /** Inferred types associated with the schema. */
-    readonly types?: Types<Input, Output> | undefined;
-  }
-  /** The result interface of the validate function. */
-  export type Result<Output> = SuccessResult<Output> | FailureResult;
-  /** The result interface if validation succeeds. */
-  export interface SuccessResult<Output> {
-    /** The typed output value. */
-    readonly value: Output;
-    /** The non-existent issues. */
-    readonly issues?: undefined;
-  }
-  /** The result interface if validation fails. */
-  export interface FailureResult {
-    /** The issues of failed validation. */
-    readonly issues: ReadonlyArray<Issue>;
-  }
-  /** The issue interface of the failure output. */
-  export interface Issue {
-    /** The error message of the issue. */
-    readonly message: string;
-    /** The path of the issue, if any. */
-    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-  }
-  /** The path segment interface of the issue. */
-  export interface PathSegment {
-    /** The key representing a path segment. */
-    readonly key: PropertyKey;
-  }
-  /** The Standard Schema types interface. */
-  export interface Types<Input = unknown, Output = Input> {
-    /** The input type of the schema. */
-    readonly input: Input;
-    /** The output type of the schema. */
-    readonly output: Output;
-  }
-  /** Infers the input type of a Standard Schema. */
-  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
-  /** Infers the output type of a Standard Schema. */
-  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
-  export {};
-}
-//#endregion
-export { StandardSchemaV1 };

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

@@ -1,41 +0,0 @@
-import { CodegenClientConfig, ExternalGraphQLService, GenericSdkConfig } from "../types/index.mjs";
-import { GraphQLSchema } from "graphql";
-import { LoadSchemaOptions, UnnormalizedTypeDefPointer } from "@graphql-tools/load";
-import { Source } from "@graphql-tools/utils";
-
-//#region src/utils/client-codegen.d.ts
-
-/**
- * Type definition pointer for GraphQL schemas
- */
-type GraphQLTypeDefPointer = UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[];
-/**
- * Options for loading GraphQL schemas
- */
-type GraphQLLoadSchemaOptions = Partial<LoadSchemaOptions>;
-declare function graphQLLoadSchemaSync(schemaPointers: GraphQLTypeDefPointer, data?: GraphQLLoadSchemaOptions): Promise<GraphQLSchema | undefined>;
-/**
- * Load schema from external GraphQL service
- */
-declare function loadExternalSchema(service: ExternalGraphQLService, buildDir?: string): Promise<GraphQLSchema | undefined>;
-/**
- * Download and save schema from external service
- */
-declare function downloadAndSaveSchema(service: ExternalGraphQLService, buildDir: string): Promise<string | undefined>;
-declare function loadGraphQLDocuments(patterns: string | string[]): Promise<Source[]>;
-declare function generateClientTypes(schema: GraphQLSchema, docs: Source[], config?: CodegenClientConfig, sdkConfig?: GenericSdkConfig, outputPath?: string, serviceName?: string, virtualTypesPath?: string, options?: {
-  silent?: boolean;
-  isInitial?: boolean;
-}): Promise<false | {
-  types: string;
-  sdk: string;
-}>;
-/**
- * Generate client types for external GraphQL service
- */
-declare function generateExternalClientTypes(service: ExternalGraphQLService, schema: GraphQLSchema, docs: Source[], virtualTypesPath?: string): Promise<{
-  types: string;
-  sdk: string;
-} | false>;
-//#endregion
-export { GraphQLLoadSchemaOptions, GraphQLTypeDefPointer, downloadAndSaveSchema, generateClientTypes, generateExternalClientTypes, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments };

package/dist/utils/client-codegen.mjs

@@ -1,277 +0,0 @@
-import { DEFAULT_GRAPHQL_SCALARS } from "../constants/scalars.mjs";
-import { pluginContent } from "./codegen-plugin.mjs";
-import { defu as defu$1 } from "defu";
-import { consola as consola$1 } from "consola";
-import { dirname, resolve } from "pathe";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { parse } from "graphql";
-import { createHash } from "node:crypto";
-import { codegen } from "@graphql-codegen/core";
-import { preset } from "@graphql-codegen/import-types-preset";
-import { plugin } from "@graphql-codegen/typed-document-node";
-import { plugin as plugin$1 } from "@graphql-codegen/typescript";
-import { plugin as plugin$2 } from "@graphql-codegen/typescript-generic-sdk";
-import { plugin as plugin$3 } from "@graphql-codegen/typescript-operations";
-import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
-import { loadDocuments, loadSchemaSync } from "@graphql-tools/load";
-import { UrlLoader } from "@graphql-tools/url-loader";
-import { printSchemaWithDirectives } from "@graphql-tools/utils";
-
-//#region src/utils/client-codegen.ts
-async function graphQLLoadSchemaSync(schemaPointers, data = {}) {
-	const filteredPointers = [...Array.isArray(schemaPointers) ? schemaPointers : [schemaPointers], "!**/vfs/**"];
-	let result;
-	try {
-		result = 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:")) consola$1.info("No server GraphQL files found. If you need server-side GraphQL, add .graphql files to your server directory.");
-		else throw e;
-	}
-	return result;
-}
-/**
-* 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 {
-				consola$1.warn(`[graphql:${service.name}] Cached schema invalid, loading from source`);
-			}
-		}
-		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 (error) {
-		consola$1.error(`[graphql:${service.name}] Failed to load external schema:`, error);
-		return;
-	}
-}
-/**
-* Check if a path is a URL (http/https)
-*/
-function isUrl(path) {
-	return path.startsWith("http://") || path.startsWith("https://");
-}
-/**
-* 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;
-					consola$1.info(`[graphql:${service.name}] Schema is up-to-date, using cached version`);
-				}
-			} catch {
-				consola$1.warn(`[graphql:${service.name}] Unable to compare with remote schema, updating local cache`);
-				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 { statSync } = await import("node:fs");
-					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) {
-			if (hasUrlSchemas && hasLocalSchemas) {
-				const schemaString = printSchemaWithDirectives(loadSchemaSync(schemas, {
-					loaders: [new GraphQLFileLoader(), new UrlLoader()],
-					...Object.keys(headers).length > 0 && { headers }
-				}));
-				mkdirSync(dirname(schemaFilePath), { recursive: true });
-				writeFileSync(schemaFilePath, schemaString, "utf-8");
-			} else if (hasUrlSchemas) {
-				const schemaString = printSchemaWithDirectives(loadSchemaSync(schemas, {
-					loaders: [new UrlLoader()],
-					...Object.keys(headers).length > 0 && { headers }
-				}));
-				mkdirSync(dirname(schemaFilePath), { recursive: true });
-				writeFileSync(schemaFilePath, schemaString, "utf-8");
-			} else if (hasLocalSchemas) {
-				const schemaString = printSchemaWithDirectives(loadSchemaSync(schemas, { loaders: [new GraphQLFileLoader()] }));
-				mkdirSync(dirname(schemaFilePath), { recursive: true });
-				writeFileSync(schemaFilePath, schemaString, "utf-8");
-			}
-		}
-		return schemaFilePath;
-	} catch (error) {
-		consola$1.error(`[graphql:${service.name}] Failed to download/copy schema:`, error);
-		return;
-	}
-}
-async function loadGraphQLDocuments(patterns) {
-	try {
-		return await loadDocuments(patterns, { loaders: [new GraphQLFileLoader()] });
-	} catch (e) {
-		if ((e.message || "").includes("Unable to find any GraphQL type definitions for the following pointers:")) return [];
-		else throw e;
-	}
-}
-async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, outputPath, serviceName, virtualTypesPath, options = {}) {
-	if (docs.length === 0 && !serviceName) {
-		if (!options.silent && options.isInitial) consola$1.info("No client GraphQL files found. Skipping client type generation.");
-		return false;
-	}
-	const serviceLabel = serviceName ? `:${serviceName}` : "";
-	const mergedConfig = defu$1({
-		emitLegacyCommonJSImports: false,
-		useTypeImports: true,
-		enumsAsTypes: true,
-		strictScalars: true,
-		maybeValue: "T | null | undefined",
-		inputMaybeValue: "T | undefined",
-		documentMode: "string",
-		pureMagicComment: true,
-		dedupeOperationSuffix: true,
-		rawRequest: true,
-		scalars: DEFAULT_GRAPHQL_SCALARS
-	}, config);
-	const mergedSdkConfig = defu$1(mergedConfig, sdkConfig);
-	try {
-		if (docs.length === 0) return {
-			types: await codegen({
-				filename: outputPath || "client-types.generated.ts",
-				schema: parse(printSchemaWithDirectives(schema)),
-				documents: [],
-				config: mergedConfig,
-				plugins: [{ pluginContent: {} }, { typescript: {} }],
-				pluginMap: {
-					pluginContent: { plugin: pluginContent },
-					typescript: { plugin: plugin$1 }
-				}
-			}),
-			sdk: `// THIS FILE IS GENERATED, DO NOT EDIT!
-/* eslint-disable eslint-comments/no-unlimited-disable */
-/* tslint:disable */
-/* eslint-disable */
-/* prettier-ignore */
-
-import type { GraphQLResolveInfo } from 'graphql'
-export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> }
-
-export interface Requester<C = {}, E = unknown> {
-  <R, V>(doc: string, vars?: V, options?: C): Promise<R> | AsyncIterable<R>
-}
-
-export type Sdk = {
-  request: <R, V = Record<string, any>>(document: string, variables?: V) => Promise<R>
-}
-
-export function getSdk(requester: Requester): Sdk {
-  return {
-    request: <R, V = Record<string, any>>(document: string, variables?: V): Promise<R> => {
-      return requester<R, V>(document, variables)
-    }
-  }
-}
-`
-		};
-		const enableTypedDocumentNode = config.typedDocumentNode === true;
-		const plugins = [
-			{ pluginContent: {} },
-			{ typescript: {} },
-			{ typescriptOperations: {} }
-		];
-		const pluginMap = {
-			pluginContent: { plugin: pluginContent },
-			typescript: { plugin: plugin$1 },
-			typescriptOperations: { plugin: plugin$3 }
-		};
-		if (enableTypedDocumentNode) {
-			plugins.push({ typedDocumentNode: {} });
-			pluginMap.typedDocumentNode = { plugin };
-		}
-		const output = await codegen({
-			filename: outputPath || "client-types.generated.ts",
-			schema: parse(printSchemaWithDirectives(schema)),
-			documents: [...docs],
-			config: mergedConfig,
-			plugins,
-			pluginMap
-		});
-		const typesPath = virtualTypesPath || (serviceName ? `#graphql/client/${serviceName}` : "#graphql/client");
-		const sdkOutput = await preset.buildGeneratesSection({
-			baseOutputDir: outputPath || "client-types.generated.ts",
-			schema: parse(printSchemaWithDirectives(schema)),
-			documents: [...docs],
-			config: mergedSdkConfig,
-			presetConfig: { typesPath },
-			plugins: [{ pluginContent: {} }, { typescriptGenericSdk: {} }],
-			pluginMap: {
-				pluginContent: { plugin: pluginContent },
-				typescriptGenericSdk: { plugin: plugin$2 }
-			}
-		});
-		return {
-			types: output,
-			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);
-		return false;
-	}
-}
-/**
-* Generate client types for external GraphQL service
-*/
-async function generateExternalClientTypes(service, schema, docs, virtualTypesPath) {
-	return generateClientTypes(schema, docs, service.codegen?.client || {}, service.codegen?.clientSDK || {}, void 0, service.name, virtualTypesPath);
-}
-
-//#endregion
-export { downloadAndSaveSchema, generateClientTypes, generateExternalClientTypes, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments };

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

@@ -1,37 +0,0 @@
-import { Nitro } from "nitro/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 };