nitro-graphql 2.0.0-beta.7 → 2.0.0-beta.70

package/dist/core/codegen/client.d.mts

@@ -0,0 +1,42 @@
+import { ClientCodegenConfig, ClientCodegenInput, ClientCodegenResult, ExternalServiceCodegenConfig } from "../types/codegen.mjs";
+import { loadGraphQLDocuments } from "./document-loader.mjs";
+import { GraphQLLoadSchemaOptions, GraphQLTypeDefPointer, downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
+import { Source } from "@graphql-tools/utils";
+import { GraphQLSchema } from "graphql";
+
+//#region src/core/codegen/client.d.ts
+/**
+ * Default client codegen configuration
+ */
+declare const DEFAULT_CLIENT_CODEGEN_CONFIG: ClientCodegenConfig;
+/**
+ * Generate client-side GraphQL types
+ * Pure function that generates TypeScript types from a GraphQL schema and documents
+ */
+declare function generateClientTypesCore(input: ClientCodegenInput): Promise<ClientCodegenResult | false>;
+/**
+ * Generate client types for external GraphQL service
+ */
+declare function generateExternalClientTypesCore(service: ExternalServiceCodegenConfig, schema: GraphQLSchema, documents: Source[], virtualTypesPath?: string): Promise<ClientCodegenResult | false>;
+/**
+ * Subscription info extracted from GraphQL documents
+ */
+interface SubscriptionInfo {
+  /** Original operation name from GraphQL document (used for method names) */
+  name: string;
+  /** PascalCase version for type references (matches GraphQL codegen output) */
+  typeName: string;
+  fieldName: string;
+  hasVariables: boolean;
+}
+/**
+ * Extract subscription operations from GraphQL documents
+ */
+declare function extractSubscriptions(docs: Source[]): SubscriptionInfo[];
+/**
+ * Generate subscription builder code (Drizzle-style API) + Vue Composables
+ * Returns empty string if subscriptions are not enabled or no subscription operations found
+ */
+declare function generateSubscriptionBuilder(docs: Source[], subscriptionsEnabled: boolean): string;
+//#endregion
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, type GraphQLLoadSchemaOptions, type GraphQLTypeDefPointer, SubscriptionInfo, downloadAndSaveSchema, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateSubscriptionBuilder, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments };

package/dist/core/codegen/client.mjs

@@ -0,0 +1,553 @@
+import { DEFAULT_GRAPHQL_SCALARS } from "../constants.mjs";
+import { pluginContent } from "./plugin.mjs";
+import { loadGraphQLDocuments } from "./document-loader.mjs";
+import { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
+import { defu as defu$1 } from "defu";
+import consola from "consola";
+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 { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { Kind, parse } from "graphql";
+
+//#region src/core/codegen/client.ts
+/**
+* Default client codegen configuration
+*/
+const DEFAULT_CLIENT_CODEGEN_CONFIG = {
+	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
+};
+/**
+* Generate generic SDK content for schema-only generation
+*/
+function generateGenericSdkContent() {
+	return `// 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)
+    }
+  }
+}
+`;
+}
+/**
+* Generate client-side GraphQL types
+* Pure function that generates TypeScript types from a GraphQL schema and documents
+*/
+async function generateClientTypesCore(input) {
+	const { schema, schemaString, documents, config = {}, sdkConfig = {}, outputPath, serviceName, virtualTypesPath } = input;
+	if (documents.length === 0 && !serviceName) return false;
+	const schemaSDL = schemaString || (schema ? printSchemaWithDirectives(schema) : null);
+	if (!schemaSDL) return false;
+	const mergedConfig = defu$1(DEFAULT_CLIENT_CODEGEN_CONFIG, config);
+	const mergedSdkConfig = defu$1(mergedConfig, sdkConfig);
+	try {
+		if (documents.length === 0) return {
+			types: await codegen({
+				filename: outputPath || "client-types.generated.ts",
+				schema: parse(schemaSDL),
+				documents: [],
+				config: mergedConfig,
+				plugins: [{ pluginContent: {} }, { typescript: {} }],
+				pluginMap: {
+					pluginContent: { plugin: pluginContent },
+					typescript: { plugin: plugin$1 }
+				}
+			}),
+			sdk: generateGenericSdkContent()
+		};
+		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(schemaSDL),
+			documents: [...documents],
+			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(schemaSDL),
+			documents: [...documents],
+			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) => {
+				return {
+					file: config.filename,
+					content: await codegen(config)
+				};
+			})))[0]?.content || ""
+		};
+	} catch (error) {
+		consola.error("[nitro-graphql] Client type generation failed:", error.message);
+		return false;
+	}
+}
+/**
+* Generate client types for external GraphQL service
+*/
+async function generateExternalClientTypesCore(service, schema, documents, virtualTypesPath) {
+	return generateClientTypesCore({
+		schema,
+		documents,
+		config: service.codegen?.client || {},
+		sdkConfig: service.codegen?.clientSDK || {},
+		serviceName: service.name,
+		virtualTypesPath
+	});
+}
+/**
+* Convert first character to uppercase (PascalCase)
+*/
+function toPascalCase(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+* Extract subscription operations from GraphQL documents
+*/
+function extractSubscriptions(docs) {
+	const subscriptions = [];
+	for (const doc of docs) {
+		if (!doc.document) continue;
+		for (const def of doc.document.definitions) if (def.kind === Kind.OPERATION_DEFINITION && def.operation === "subscription") {
+			const operationDef = def;
+			const name = operationDef.name?.value;
+			if (!name) continue;
+			const firstSelection = operationDef.selectionSet.selections[0];
+			if (firstSelection.kind !== Kind.FIELD) continue;
+			const fieldName = firstSelection.name.value;
+			const hasVariables = (operationDef.variableDefinitions?.length || 0) > 0;
+			subscriptions.push({
+				name,
+				typeName: toPascalCase(name),
+				fieldName,
+				hasVariables
+			});
+		}
+	}
+	return subscriptions;
+}
+/**
+* Generate subscription builder code (Drizzle-style API) + Vue Composables
+* Returns empty string if subscriptions are not enabled or no subscription operations found
+*/
+function generateSubscriptionBuilder(docs, subscriptionsEnabled) {
+	if (!subscriptionsEnabled) return "";
+	const subscriptions = extractSubscriptions(docs);
+	if (subscriptions.length === 0) return "";
+	let output = `
+// === Subscription Imports ===
+import { ref, onUnmounted, computed } from 'vue'
+import type { Ref } from 'vue'
+import type {
+  ConnectionState,
+  SubscriptionHandle,
+  SubscriptionSession,
+  SubscriptionTransport,
+  TransportOptions,
+} from 'nitro-graphql/subscribe'
+import { subscriptionClient } from './subscribe'
+
+// === Subscription Types ===
+export type { ConnectionState, SubscriptionHandle, SubscriptionSession, SubscriptionTransport, TransportOptions }
+
+// Forward declaration for UseSubscriptionSessionReturn (defined below)
+export interface UseSubscriptionSessionReturn {
+  /** The underlying session object */
+  session: SubscriptionSession
+  /** Subscribe using the shared session (updates reactive refs) */
+  subscribe: <TData = unknown>(
+    query: string,
+    variables: unknown,
+    onData?: (data: TData) => void,
+    onError?: (error: Error) => void,
+  ) => SubscriptionHandle
+  /** Close all subscriptions and the connection */
+  close: () => void
+  /** Is the session connected (reactive) */
+  isConnected: Ref<boolean>
+  /** Current connection state (reactive) */
+  state: Ref<ConnectionState>
+  /** Number of active subscriptions (reactive) */
+  subscriptionCount: Ref<number>
+}
+
+export interface UseSubscriptionOptions<T> {
+  /** Auto-start subscription on mount (default: false) */
+  immediate?: boolean
+  /** Callback when subscription starts */
+  onStart?: () => void
+  /** Callback when subscription stops */
+  onStop?: () => void
+  /** Callback when data is received */
+  onData?: (data: T) => void
+  /** Callback when error occurs */
+  onError?: (error: Error) => void
+  /** Callback when WebSocket connects */
+  onConnected?: () => void
+  /** Callback when WebSocket reconnects */
+  onReconnected?: () => void
+  /** Callback when WebSocket disconnects */
+  onDisconnected?: () => void
+  /** Callback when connection state changes */
+  onStateChange?: (state: ConnectionState) => void
+  /** Use existing session for multiplexing (pass result from useSubscriptionSession) */
+  session?: UseSubscriptionSessionReturn
+  /** Transport type: 'websocket' (default), 'sse', or 'auto' (WS first, SSE fallback) */
+  transport?: SubscriptionTransport
+}
+
+export interface UseSubscriptionReturn<T> {
+  /** Reactive subscription data */
+  data: Ref<T | null>
+  /** Reactive error state */
+  error: Ref<Error | null>
+  /** Is subscription active */
+  isActive: Ref<boolean>
+  /** Connection state */
+  state: Ref<ConnectionState>
+  /** Active transport type ('websocket' | 'sse') */
+  transport: Ref<'websocket' | 'sse'>
+  /** Start subscription */
+  start: () => void
+  /** Stop subscription */
+  stop: () => void
+  /** Restart subscription */
+  restart: () => void
+}
+
+// === Subscription Builder (Drizzle-style API) ===
+interface SubscriptionBuilder<TData> {
+  onData(fn: (data: TData) => void): SubscriptionBuilder<TData>
+  onError(fn: (error: Error) => void): SubscriptionBuilder<TData>
+  start(): SubscriptionHandle
+  subscribe(fn: (data: TData) => void): SubscriptionHandle
+}
+
+function createSubscriptionBuilder<TData>(query: string, variables: unknown): SubscriptionBuilder<TData> {
+  let onDataFn: ((data: TData) => void) | undefined
+  let onErrorFn: ((error: Error) => void) | undefined
+
+  const builder: SubscriptionBuilder<TData> = {
+    onData(fn: (data: TData) => void) {
+      onDataFn = fn
+      return builder
+    },
+    onError(fn: (error: Error) => void) {
+      onErrorFn = fn
+      return builder
+    },
+    start(): SubscriptionHandle {
+      return subscriptionClient.subscribe(query, variables, onDataFn, onErrorFn)
+    },
+    subscribe(fn: (data: TData) => void): SubscriptionHandle {
+      return subscriptionClient.subscribe(query, variables, fn, undefined)
+    },
+  }
+
+  return builder
+}
+
+export const subscription = {
+`;
+	for (const sub of subscriptions) if (sub.hasVariables) output += `  ${sub.typeName}(variables: Types.${sub.typeName}SubscriptionVariables): SubscriptionBuilder<Types.${sub.typeName}Subscription['${sub.fieldName}']> {
+    return createSubscriptionBuilder<Types.${sub.typeName}Subscription['${sub.fieldName}']>(${sub.typeName}Document, variables)
+  },
+`;
+	else output += `  ${sub.typeName}(): SubscriptionBuilder<Types.${sub.typeName}Subscription['${sub.fieldName}']> {
+    return createSubscriptionBuilder<Types.${sub.typeName}Subscription['${sub.fieldName}']>(${sub.typeName}Document, undefined)
+  },
+`;
+	output += `}
+
+// === Framework-Agnostic Session (for non-Vue usage) ===
+/**
+ * Create a multiplexed subscription session (framework-agnostic)
+ * All subscriptions share a single WebSocket connection.
+ *
+ * @example
+ * // Vanilla JS / Node.js / React / etc.
+ * const session = createSubscriptionSession()
+ * const sub1 = session.subscribe(query1, vars1, onData1)
+ * const sub2 = session.subscribe(query2, vars2, onData2)
+ * // Both use the same WebSocket connection
+ * sub1.unsubscribe()
+ * session.close() // Close all
+ *
+ * @returns SubscriptionSession - Framework-agnostic session object
+ */
+export function createSubscriptionSession(): SubscriptionSession {
+  return subscriptionClient.createSession()
+}
+
+// === Vue Composable: useSubscriptionSession (Multiplexing) ===
+export interface UseSubscriptionSessionReturn {
+  /** The underlying session object */
+  session: SubscriptionSession
+  /** Subscribe using the shared session */
+  subscribe: <TData = unknown>(
+    query: string,
+    variables: unknown,
+    onData?: (data: TData) => void,
+    onError?: (error: Error) => void,
+  ) => SubscriptionHandle
+  /** Close all subscriptions and the connection */
+  close: () => void
+  /** Is the session connected (reactive) */
+  isConnected: Ref<boolean>
+  /** Current connection state (reactive) */
+  state: Ref<ConnectionState>
+  /** Number of active subscriptions (reactive) */
+  subscriptionCount: Ref<number>
+}
+
+/**
+ * Vue composable for multiplexed subscription session
+ * Provides reactive state and automatic cleanup on unmount.
+ *
+ * @example
+ * // Vue 3 component
+ * const session = useSubscriptionSession()
+ * const { data } = useCountdown({ from: 10 }, { session })
+ * // Session auto-closes on component unmount
+ *
+ * @returns UseSubscriptionSessionReturn - Vue-reactive session wrapper
+ */
+export function useSubscriptionSession(): UseSubscriptionSessionReturn {
+  const session = subscriptionClient.createSession()
+
+  // Use refs for reactivity (session getters are not reactive)
+  const isConnected = ref(session.isConnected)
+  const state = ref<ConnectionState>(session.state)
+  const subscriptionCount = ref(session.subscriptionCount)
+
+  // Update refs when session state changes
+  function updateRefs() {
+    isConnected.value = session.isConnected
+    state.value = session.state
+    subscriptionCount.value = session.subscriptionCount
+  }
+
+  // Subscribe to session state changes for automatic reactivity
+  const unsubscribeStateChange = session.onStateChange(() => {
+    updateRefs()
+  })
+
+  function subscribe<TData = unknown>(
+    query: string,
+    variables: unknown,
+    onData?: (data: TData) => void,
+    onError?: (error: Error) => void,
+  ): SubscriptionHandle {
+    return session.subscribe(query, variables, onData as (data: unknown) => void, onError)
+  }
+
+  function close() {
+    session.close()
+  }
+
+  onUnmounted(() => {
+    unsubscribeStateChange()
+    close()
+  })
+
+  return {
+    session,
+    subscribe,
+    close,
+    isConnected,
+    state,
+    subscriptionCount,
+  }
+}
+
+// === Vue Composables ===
+function createUseSubscription<TData, TVariables = undefined>(
+  query: string,
+  getVariables: () => TVariables,
+): (options?: UseSubscriptionOptions<TData>) => UseSubscriptionReturn<TData> {
+  return (options: UseSubscriptionOptions<TData> = {}): UseSubscriptionReturn<TData> => {
+    const data = ref<TData | null>(null) as Ref<TData | null>
+    const error = ref<Error | null>(null)
+    const isActive = ref(false)
+    const state = ref<ConnectionState>('idle')
+    const transport = ref<'websocket' | 'sse'>('websocket')
+    let handle: SubscriptionHandle | null = null
+
+    // Resolve transport options
+    const transportOptions: TransportOptions = {
+      transport: options.transport,
+    }
+
+    function start() {
+      stop()
+      isActive.value = true
+      error.value = null
+      options.onStart?.()
+
+      const variables = getVariables()
+
+      if (options.session) {
+        // Use existing session for multiplexing (WebSocket only)
+        handle = options.session.subscribe<TData>(
+          query,
+          variables,
+          (d: TData) => {
+            data.value = d
+            options.onData?.(d)
+          },
+          (e: Error) => {
+            error.value = e
+            options.onError?.(e)
+          },
+        )
+        transport.value = 'websocket'
+      } else {
+        // Create dedicated connection with transport selection
+        handle = subscriptionClient.subscribe<TData>(
+          query,
+          variables,
+          (d: TData) => {
+            data.value = d
+            options.onData?.(d)
+          },
+          (e: Error) => {
+            error.value = e
+            options.onError?.(e)
+          },
+          transportOptions,
+        )
+        // Update transport ref from handle
+        transport.value = handle.transport
+      }
+    }
+
+    function stop() {
+      if (handle) {
+        handle.unsubscribe()
+        handle = null
+        isActive.value = false
+        options.onStop?.()
+      }
+    }
+
+    function restart() {
+      stop()
+      start()
+    }
+
+    if (options.immediate) {
+      start()
+    }
+
+    onUnmounted(stop)
+
+    return { data, error, isActive, state, transport, start, stop, restart }
+  }
+}
+
+// === Subscription Return Types ===
+`;
+	for (const sub of subscriptions) {
+		const typeName = `Types.${sub.typeName}Subscription['${sub.fieldName}']`;
+		output += `/** Return type for use${sub.typeName} composable */
+export type Use${sub.typeName}Return = UseSubscriptionReturn<${typeName}>
+`;
+	}
+	output += `
+// === Vue Composables ===
+`;
+	for (const sub of subscriptions) {
+		const typeName = `Types.${sub.typeName}Subscription['${sub.fieldName}']`;
+		const varsType = `Types.${sub.typeName}SubscriptionVariables`;
+		if (sub.hasVariables) output += `/**
+ * Vue composable for ${sub.typeName} subscription
+ * @param variables - Subscription variables
+ * @param options - Subscription options (immediate, onData, onError, session, etc.)
+ * @returns Reactive subscription state: { data, error, isActive, state, start, stop, restart }
+ */
+export function use${sub.typeName}(
+  variables: ${varsType},
+  options?: UseSubscriptionOptions<${typeName}>,
+): Use${sub.typeName}Return {
+  return createUseSubscription<${typeName}, ${varsType}>(
+    ${sub.typeName}Document,
+    () => variables,
+  )(options)
+}
+
+`;
+		else output += `/**
+ * Vue composable for ${sub.typeName} subscription
+ * @param options - Subscription options (immediate, onData, onError, session, etc.)
+ * @returns Reactive subscription state: { data, error, isActive, state, start, stop, restart }
+ */
+export function use${sub.typeName}(
+  options?: UseSubscriptionOptions<${typeName}>,
+): Use${sub.typeName}Return {
+  return createUseSubscription<${typeName}, undefined>(
+    ${sub.typeName}Document,
+    () => undefined,
+  )(options)
+}
+
+`;
+	}
+	return output;
+}
+
+//#endregion
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, downloadAndSaveSchema, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateSubscriptionBuilder, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments };

package/dist/core/codegen/document-loader.d.mts

@@ -0,0 +1,9 @@
+import { Source } from "@graphql-tools/utils";
+
+//#region src/core/codegen/document-loader.d.ts
+/**
+ * Load GraphQL documents from files
+ */
+declare function loadGraphQLDocuments(patterns: string | string[]): Promise<Source[]>;
+//#endregion
+export { loadGraphQLDocuments };

package/dist/core/codegen/document-loader.mjs

@@ -0,0 +1,18 @@
+import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
+import { loadDocuments } from "@graphql-tools/load";
+
+//#region src/core/codegen/document-loader.ts
+/**
+* Load GraphQL documents from files
+*/
+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 [];
+		throw e;
+	}
+}
+
+//#endregion
+export { loadGraphQLDocuments };

package/dist/core/codegen/index.d.mts

@@ -0,0 +1,8 @@
+import { loadGraphQLDocuments } from "./document-loader.mjs";
+import { GraphQLLoadSchemaOptions, GraphQLTypeDefPointer, downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
+import { DEFAULT_CLIENT_CODEGEN_CONFIG, SubscriptionInfo, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateSubscriptionBuilder } from "./client.mjs";
+import { GENERATED_FILE_HEADER, pluginContent } from "./plugin.mjs";
+import { generateResolverModule, generateRuntimeIndex, generateSchemaModule } from "./runtime.mjs";
+import { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore, generateTypes } from "./server.mjs";
+import { validateNoDuplicateTypes, validateSchemaFiles } from "./validation.mjs";
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_SERVER_CODEGEN_CONFIG, GENERATED_FILE_HEADER, type GraphQLLoadSchemaOptions, type GraphQLTypeDefPointer, type SubscriptionInfo, downloadAndSaveSchema, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateSubscriptionBuilder, generateTypes, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments, pluginContent, validateNoDuplicateTypes, validateSchemaFiles };

package/dist/core/codegen/index.mjs

@@ -0,0 +1,9 @@
+import { GENERATED_FILE_HEADER, pluginContent } from "./plugin.mjs";
+import { loadGraphQLDocuments } from "./document-loader.mjs";
+import { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema } from "./schema-loader.mjs";
+import { DEFAULT_CLIENT_CODEGEN_CONFIG, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateSubscriptionBuilder } from "./client.mjs";
+import { generateResolverModule, generateRuntimeIndex, generateSchemaModule } from "./runtime.mjs";
+import { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore, generateTypes } from "./server.mjs";
+import { validateNoDuplicateTypes, validateSchemaFiles } from "./validation.mjs";
+
+export { DEFAULT_CLIENT_CODEGEN_CONFIG, DEFAULT_SERVER_CODEGEN_CONFIG, GENERATED_FILE_HEADER, downloadAndSaveSchema, extractSubscriptions, generateClientTypesCore, generateExternalClientTypesCore, generateResolverModule, generateRuntimeIndex, generateSchemaModule, generateServerTypesCore, generateSubscriptionBuilder, generateTypes, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments, pluginContent, validateNoDuplicateTypes, validateSchemaFiles };

package/dist/core/codegen/plugin.d.mts

@@ -0,0 +1,19 @@
+import { Source } from "@graphql-tools/utils";
+import { GraphQLSchema } from "graphql";
+
+//#region src/core/codegen/plugin.d.ts
+/**
+ * Plugin to add prepend comments to generated files
+ * Used by both server and client codegen
+ */
+declare function pluginContent(_schema: GraphQLSchema, _documents: Source[], _config: Record<string, unknown> | undefined, _info: Record<string, unknown> | undefined): {
+  prepend: string[];
+  content: string;
+};
+/**
+ * Generate the prepend header for generated files
+ * Can be used when creating files manually without codegen
+ */
+declare const GENERATED_FILE_HEADER = "// THIS FILE IS GENERATED, DO NOT EDIT!\n/* eslint-disable eslint-comments/no-unlimited-disable */\n/* tslint:disable */\n/* eslint-disable */\n/* prettier-ignore */\n";
+//#endregion
+export { GENERATED_FILE_HEADER, pluginContent };

package/dist/core/codegen/plugin.mjs

@@ -0,0 +1,30 @@
+//#region src/core/codegen/plugin.ts
+/**
+* Plugin to add prepend comments to generated files
+* Used by both server and client codegen
+*/
+function pluginContent(_schema, _documents, _config, _info) {
+	return {
+		prepend: [
+			"// THIS FILE IS GENERATED, DO NOT EDIT!",
+			"/* eslint-disable eslint-comments/no-unlimited-disable */",
+			"/* tslint:disable */",
+			"/* eslint-disable */",
+			"/* prettier-ignore */"
+		],
+		content: ""
+	};
+}
+/**
+* Generate the prepend header for generated files
+* Can be used when creating files manually without codegen
+*/
+const GENERATED_FILE_HEADER = `// THIS FILE IS GENERATED, DO NOT EDIT!
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+`;
+
+//#endregion
+export { GENERATED_FILE_HEADER, pluginContent };