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

package/dist/types/index.d.mts

@@ -1,246 +0,0 @@
-import { StandardSchemaV1 } from "./standard-schema.mjs";
-import { TypeScriptPluginConfig } from "@graphql-codegen/typescript";
-import { plugin as plugin$1 } from "@graphql-codegen/typescript-generic-sdk";
-import { TypeScriptDocumentsPluginConfig } from "@graphql-codegen/typescript-operations";
-import { IResolvers } from "@graphql-tools/utils";
-import { TypeScriptResolversPluginConfig } from "@graphql-codegen/typescript-resolvers";
-import { ESMCodeGenOptions } from "knitwork";
-
-//#region src/types/index.d.ts
-type CodegenServerConfig = TypeScriptPluginConfig & TypeScriptResolversPluginConfig;
-type DocumentModeConfig = Pick<Parameters<typeof plugin$1>[2], 'documentMode'>;
-type DocumentModeEnum = NonNullable<DocumentModeConfig['documentMode']>;
-type DocumentModeType = `${DocumentModeEnum}`;
-type GenericSdkConfig = Omit<Parameters<typeof plugin$1>[2], 'documentMode'> & {
-  documentMode?: DocumentModeType;
-};
-type CodegenClientConfig = TypeScriptPluginConfig & TypeScriptDocumentsPluginConfig & {
-  endpoint?: string;
-};
-interface IESMImport {
-  name: string;
-  as?: string;
-  type: 'resolver' | 'query' | 'mutation' | 'type' | 'subscription' | 'directive';
-}
-interface GenImport {
-  specifier: string;
-  imports: IESMImport[];
-  options?: ESMCodeGenOptions;
-}
-declare module 'nitro/types' {
-  interface Nitro {
-    scanSchemas: string[];
-    scanDocuments: string[];
-    scanResolvers: GenImport[];
-    scanDirectives: GenImport[];
-    graphql: {
-      buildDir: string;
-      watchDirs: string[];
-      clientDir: string;
-      serverDir: string;
-      dir: {
-        build: string;
-        client: string;
-        server: string;
-      };
-    };
-  }
-}
-declare module 'nitro/types' {
-  interface NitroOptions {
-    graphql?: NitroGraphQLOptions;
-  }
-  interface NitroRuntimeConfig {
-    graphql?: NitroGraphQLOptions;
-  }
-  interface NitroConfig {
-    graphql?: NitroGraphQLOptions;
-  }
-}
-/**
- * Service-specific path overrides for external GraphQL services
- * These paths override global config for this specific service
- */
-interface ExternalServicePaths {
-  /** SDK file path (overrides global sdk.external config) */
-  sdk?: FileGenerationConfig;
-  /** Type definitions file path (overrides global types.external config) */
-  types?: FileGenerationConfig;
-  /** ofetch client wrapper path (overrides global clientUtils.ofetch config) */
-  ofetch?: FileGenerationConfig;
-}
-interface ExternalGraphQLService {
-  /** Unique name for this service (used for file naming and type generation) */
-  name: string;
-  /** Schema source - can be URL(s) for remote schemas or file path(s) for local schemas */
-  schema: string | string[];
-  /** GraphQL endpoint for this service */
-  endpoint: string;
-  /** Optional headers for schema introspection and client requests */
-  headers?: Record<string, string> | (() => Record<string, string>);
-  /** Optional: specific document patterns for this service */
-  documents?: string[];
-  /**
-   * Optional: Download and cache schema locally for offline usage
-   * - true or 'once': Download if file doesn't exist, then use cached version (offline-friendly)
-   * - 'always': Check for updates on every build (current behavior)
-   * - 'manual': Never download automatically, user manages schema files manually
-   * - false: Disable schema downloading
-   */
-  downloadSchema?: boolean | 'once' | 'always' | 'manual';
-  /** Optional: Custom path to save downloaded schema (default: .nitro/graphql/schemas/[serviceName].graphql) */
-  downloadPath?: string;
-  /** Optional: service-specific codegen configuration */
-  codegen?: {
-    client?: CodegenClientConfig;
-    clientSDK?: GenericSdkConfig;
-  };
-  /**
-   * Optional: Service-specific path overrides
-   * These paths take precedence over global config (sdk, types, clientUtils)
-   * Supports placeholders: {serviceName}, {buildDir}, {rootDir}, {framework}, {typesDir}, {clientGraphql}
-   */
-  paths?: ExternalServicePaths;
-}
-interface FederationConfig {
-  /** Enable Apollo Federation subgraph support */
-  enabled: boolean;
-  /** Service name for federation (used in subgraph config) */
-  serviceName?: string;
-  /** Service version for federation */
-  serviceVersion?: string;
-  /** Service URL for federation gateway */
-  serviceUrl?: string;
-}
-/**
- * File generation control:
- * - false: Do not generate this file
- * - true: Generate at default location
- * - string: Generate at custom path (supports placeholders: {serviceName}, {buildDir}, {rootDir}, {framework})
- */
-type FileGenerationConfig = boolean | string;
-/**
- * Scaffold files configuration
- * Control auto-generation of scaffold/boilerplate files
- */
-interface ScaffoldConfig {
-  /** Enable/disable all scaffold files */
-  enabled?: boolean;
-  /** graphql.config.ts - GraphQL Config file for IDE tooling */
-  graphqlConfig?: FileGenerationConfig;
-  /** server/graphql/schema.ts - Schema definition file */
-  serverSchema?: FileGenerationConfig;
-  /** server/graphql/config.ts - GraphQL server configuration */
-  serverConfig?: FileGenerationConfig;
-  /** server/graphql/context.ts - H3 context augmentation */
-  serverContext?: FileGenerationConfig;
-}
-/**
- * Client utilities configuration
- * Control auto-generation of client-side utility files (Nuxt only)
- */
-interface ClientUtilsConfig {
-  /** Enable/disable all client utilities */
-  enabled?: boolean;
-  /** app/graphql/index.ts - Main exports file */
-  index?: FileGenerationConfig;
-  /** app/graphql/{serviceName}/ofetch.ts - ofetch client wrapper */
-  ofetch?: FileGenerationConfig;
-}
-/**
- * SDK files configuration
- * Control auto-generation of GraphQL SDK files
- */
-interface SdkConfig {
-  /** Enable/disable all SDK files */
-  enabled?: boolean;
-  /** app/graphql/default/sdk.ts - Main service SDK */
-  main?: FileGenerationConfig;
-  /** app/graphql/{serviceName}/sdk.ts - External service SDKs */
-  external?: FileGenerationConfig;
-}
-/**
- * Type files configuration
- * Control auto-generation of TypeScript type definition files
- */
-interface TypesConfig {
-  /** Enable/disable all type files */
-  enabled?: boolean;
-  /** .nitro/types/nitro-graphql-server.d.ts - Server-side types */
-  server?: FileGenerationConfig;
-  /** .nitro/types/nitro-graphql-client.d.ts - Client-side types */
-  client?: FileGenerationConfig;
-  /** .nitro/types/nitro-graphql-client-{serviceName}.d.ts - External service types */
-  external?: FileGenerationConfig;
-}
-/**
- * Global path overrides
- * Set base directories for file generation
- */
-interface PathsConfig {
-  /** Server GraphQL directory (default: 'server/graphql') */
-  serverGraphql?: string;
-  /** Client GraphQL directory (default: 'app/graphql' for Nuxt, 'graphql' for Nitro) */
-  clientGraphql?: string;
-  /** Build directory (default: '.nitro' or '.nuxt') */
-  buildDir?: string;
-  /** Types directory (default: '{buildDir}/types') */
-  typesDir?: string;
-}
-interface NitroGraphQLOptions {
-  framework?: 'graphql-yoga' | 'apollo-server';
-  endpoint?: {
-    graphql?: string;
-    healthCheck?: string;
-  };
-  playground?: boolean;
-  typedefs?: string[];
-  resolvers?: Array<IResolvers<any, any>>;
-  loader?: {
-    include?: RegExp;
-    exclude?: RegExp;
-    validate?: boolean;
-  };
-  codegen?: {
-    server?: CodegenServerConfig;
-    client?: CodegenClientConfig;
-    clientSDK?: GenericSdkConfig;
-  };
-  /** External GraphQL services to generate types and SDKs for */
-  externalServices?: ExternalGraphQLService[];
-  /** Apollo Federation configuration */
-  federation?: FederationConfig;
-  /** Server GraphQL directory path */
-  serverDir?: string;
-  /** Layer directories (populated by Nuxt module) */
-  layerDirectories?: string[];
-  layerServerDirs?: string[];
-  layerAppDirs?: string[];
-  /**
-   * Scaffold files configuration
-   * Set to false to disable all scaffold file generation (library mode)
-   */
-  scaffold?: false | ScaffoldConfig;
-  /**
-   * Client utilities configuration
-   * Set to false to disable all client utility generation
-   */
-  clientUtils?: false | ClientUtilsConfig;
-  /**
-   * SDK files configuration
-   * Set to false to disable all SDK generation
-   */
-  sdk?: false | SdkConfig;
-  /**
-   * Type files configuration
-   * Set to false to disable all type generation
-   */
-  types?: false | TypesConfig;
-  /**
-   * Global path overrides
-   * Customize base directories for file generation
-   */
-  paths?: PathsConfig;
-}
-//#endregion
-export { ClientUtilsConfig, CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions, PathsConfig, ScaffoldConfig, SdkConfig, StandardSchemaV1, TypesConfig };

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,267 +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/typescript";
-import { plugin as plugin$1 } from "@graphql-codegen/typescript-generic-sdk";
-import { plugin as plugin$2 } 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 schemas = Array.isArray(service.schema) ? service.schema : [service.schema];
-		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 schemas = Array.isArray(service.schema) ? service.schema : [service.schema];
-		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 }
-				}
-			}),
-			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 output = await codegen({
-			filename: outputPath || "client-types.generated.ts",
-			schema: parse(printSchemaWithDirectives(schema)),
-			documents: [...docs],
-			config: mergedConfig,
-			plugins: [
-				{ pluginContent: {} },
-				{ typescript: {} },
-				{ typescriptOperations: {} }
-			],
-			pluginMap: {
-				pluginContent: { plugin: pluginContent },
-				typescript: { plugin },
-				typescriptOperations: { plugin: plugin$2 }
-			}
-		});
-		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$1 }
-			}
-		});
-		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 };