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

package/dist/{utils → core/utils}/ofetch-templates.d.mts

@@ -1,4 +1,4 @@
-//#region src/utils/ofetch-templates.d.ts
+//#region src/core/utils/ofetch-templates.d.ts
 /**
  * Shared ofetch template generation utilities
  * Used by both main client and external service code generation

package/dist/{utils → core/utils}/ofetch-templates.mjs

@@ -1,4 +1,4 @@
-//#region src/utils/ofetch-templates.ts
+//#region src/core/utils/ofetch-templates.ts
 /**
 * Capitalize first letter of a string
 */

package/dist/core/validation/external-services.d.mts

@@ -0,0 +1,11 @@
+//#region src/core/validation/external-services.d.ts
+/**
+ * External services validation utilities
+ * Framework-agnostic validation helpers
+ */
+/**
+ * Validate external GraphQL service configuration
+ */
+declare function validateExternalServices(services: unknown[]): string[];
+//#endregion
+export { validateExternalServices };

package/dist/{utils/validation.mjs → core/validation/external-services.mjs}

@@ -1,7 +1,7 @@
-//#region src/utils/validation.ts
+//#region src/core/validation/external-services.ts
 /**
-* Validation utilities
-* Configuration validation helpers
+* External services validation utilities
+* Framework-agnostic validation helpers
 */
 /**
 * Validate external GraphQL service configuration

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

@@ -0,0 +1,2 @@
+import { validateExternalServices } from "./external-services.mjs";
+export { validateExternalServices };

package/dist/core/validation/index.mjs

@@ -0,0 +1,3 @@
+import { validateExternalServices } from "./external-services.mjs";
+
+export { validateExternalServices };

package/dist/define.d.mts

@@ -1,6 +1,4 @@
-import { StandardSchemaV1 } from "./types/standard-schema.mjs";
-import "./types/index.mjs";
-import { DefineDirectiveConfig, DefineServerConfig, DirectiveDefinition, Flatten } from "./types/define.mjs";
+import { DefineDirectiveConfig, DefineServerConfig, DirectiveDefinition, Flatten, StandardSchemaV1 } from "./nitro/types.mjs";
 import { NPMConfig, Resolvers, ResolversTypes } from "#graphql/server";
 
 //#region src/define.d.ts
@@ -197,7 +195,7 @@ declare function defineField(resolvers: Resolvers): Resolvers;
  *
  * @example
  * ```typescript
- * import { createDefaultMaskError } from 'nitro-graphql/utils'
+ * import { createDefaultMaskError } from 'nitro-graphql/core'
  *
  * // GraphQL Yoga configuration
  * export default defineGraphQLConfig({

package/dist/define.mjs

@@ -203,7 +203,7 @@ function defineField(resolvers) {
 *
 * @example
 * ```typescript
-* import { createDefaultMaskError } from 'nitro-graphql/utils'
+* import { createDefaultMaskError } from 'nitro-graphql/core'
 *
 * // GraphQL Yoga configuration
 * export default defineGraphQLConfig({

package/dist/index.d.mts

@@ -1,44 +1,6 @@
-import { NitroGraphQLOptions } from "./types/index.mjs";
-import { resolveSecurityConfig } from "./setup.mjs";
-import { NitroModule } from "nitro/types";
-import { Plugin } from "vite";
-
-//#region src/index.d.ts
-
-/**
- * Vite plugin to load GraphQL files as strings AND auto-register Nitro module
- * This prevents Vite from trying to parse .graphql/.gql files as JavaScript
- * and automatically sets up the nitro-graphql module via the nitro: hook
- *
- * @example - Vite usage
- * ```ts
- * import { defineConfig } from 'vite'
- * import { nitro } from 'nitro/vite'
- * import graphql from 'nitro-graphql'
- *
- * export default defineConfig({
- *   plugins: [
- *     graphql({ framework: 'graphql-yoga' }), // Auto-registers Nitro module
- *     nitro()
- *   ]
- * })
- * ```
- *
- *
- * @example - Nitro direct usage
- * ```ts
- *
- * import graphql from 'nitro-graphql'
- *
- * export default defineConfig({
- *   modules: [
- *    graphql({ framework: 'graphql-yoga' }) // Auto-registers Nitro module
- *   ]
- * })
- * ```
- */
-declare function graphqlModule(options?: NitroGraphQLOptions): Plugin & {
-  nitro?: NitroModule;
-};
-//#endregion
-export { graphqlModule as default, resolveSecurityConfig };
+import { ExternalGraphQLService, NitroGraphQLOptions, SecurityConfig } from "./nitro/types.mjs";
+import { NitroAdapter } from "./nitro/adapter.mjs";
+import { resolveSecurityConfig } from "./nitro/setup/logging.mjs";
+import { setupNitroGraphQL } from "./nitro/setup.mjs";
+import graphqlModule from "./nitro/index.mjs";
+export { type ExternalGraphQLService, NitroAdapter, type NitroGraphQLOptions, type SecurityConfig, graphqlModule as default, resolveSecurityConfig, setupNitroGraphQL };

package/dist/index.mjs

@@ -1,63 +1,6 @@
-import { resolveSecurityConfig, setupNitroGraphQL } from "./setup.mjs";
-import { readFile } from "node:fs/promises";
-import defu from "defu";
+import { NitroAdapter } from "./nitro/adapter.mjs";
+import { resolveSecurityConfig } from "./nitro/setup/logging.mjs";
+import { setupNitroGraphQL } from "./nitro/setup.mjs";
+import nitro_default from "./nitro/index.mjs";
 
-//#region src/index.ts
-/**
-* Vite plugin to load GraphQL files as strings AND auto-register Nitro module
-* This prevents Vite from trying to parse .graphql/.gql files as JavaScript
-* and automatically sets up the nitro-graphql module via the nitro: hook
-*
-* @example - Vite usage
-* ```ts
-* import { defineConfig } from 'vite'
-* import { nitro } from 'nitro/vite'
-* import graphql from 'nitro-graphql'
-*
-* export default defineConfig({
-*   plugins: [
-*     graphql({ framework: 'graphql-yoga' }), // Auto-registers Nitro module
-*     nitro()
-*   ]
-* })
-* ```
-*
-*
-* @example - Nitro direct usage
-* ```ts
-*
-* import graphql from 'nitro-graphql'
-*
-* export default defineConfig({
-*   modules: [
-*    graphql({ framework: 'graphql-yoga' }) // Auto-registers Nitro module
-*   ]
-* })
-* ```
-*/
-function graphqlModule(options) {
-	return {
-		name: "nitro-graphql",
-		enforce: "pre",
-		async load(id) {
-			if (!/\.(?:graphql|gql)$/i.test(id)) return null;
-			try {
-				const content = await readFile(id, "utf-8");
-				return `export default ${JSON.stringify(content)}`;
-			} catch (error) {
-				if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return null;
-				throw error;
-			}
-		},
-		nitro: { async setup(nitro) {
-			if (options) nitro.options.graphql = defu(nitro.options.graphql || {}, options);
-			nitro.options.graphql = nitro.options.graphql || {};
-			nitro.options.graphql._vitePlugin = true;
-			await setupNitroGraphQL(nitro);
-		} }
-	};
-}
-var src_default = graphqlModule;
-
-//#endregion
-export { src_default as default, resolveSecurityConfig };
+export { NitroAdapter, nitro_default as default, resolveSecurityConfig, setupNitroGraphQL };

package/dist/nitro/adapter.d.mts

@@ -0,0 +1,30 @@
+import { CoreConfig, CoreContext, CoreLogger } from "../core/types/config.mjs";
+import { ScanContext } from "../core/types/scanning.mjs";
+import "../core/types/index.mjs";
+import { FrameworkAdapter, ScanAdapter } from "../core/types/adapter.mjs";
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/adapter.d.ts
+
+/**
+ * Create a CoreLogger from Nitro's logger
+ */
+declare function createLoggerFromNitro(nitro: Nitro): CoreLogger;
+/**
+ * Create a ScanContext from Nitro instance
+ */
+declare function createScanContextFromNitro(nitro: Nitro): ScanContext;
+/**
+ * Create a CoreConfig from Nitro instance
+ */
+declare function createCoreConfigFromNitro(nitro: Nitro): CoreConfig;
+/**
+ * Create a CoreContext from Nitro instance
+ */
+declare function createCoreContextFromNitro(nitro: Nitro): CoreContext;
+/**
+ * Nitro framework adapter implementation
+ */
+declare const NitroAdapter: FrameworkAdapter<Nitro> & ScanAdapter<Nitro>;
+//#endregion
+export { NitroAdapter, NitroAdapter as default, createCoreConfigFromNitro, createCoreContextFromNitro, createLoggerFromNitro, createScanContextFromNitro };

package/dist/nitro/adapter.mjs

@@ -0,0 +1,97 @@
+import { scanDirectivesCore } from "../core/scanning/directives.mjs";
+import { scanDocumentsCore } from "../core/scanning/documents.mjs";
+import { scanResolversCore } from "../core/scanning/resolvers.mjs";
+import { scanGraphqlCore, scanSchemasCore } from "../core/scanning/schemas.mjs";
+import { join, relative } from "pathe";
+
+//#region src/nitro/adapter.ts
+/**
+* Create a CoreLogger from Nitro's logger
+*/
+function createLoggerFromNitro(nitro) {
+	return {
+		info: (msg, ...args) => nitro.logger.info(msg, ...args),
+		warn: (msg, ...args) => nitro.logger.warn(msg, ...args),
+		error: (msg, ...args) => nitro.logger.error(msg, ...args),
+		success: (msg, ...args) => nitro.logger.success(msg, ...args),
+		debug: (msg, ...args) => nitro.logger.debug(msg, ...args)
+	};
+}
+/**
+* Create a ScanContext from Nitro instance
+*/
+function createScanContextFromNitro(nitro) {
+	return {
+		rootDir: nitro.options.rootDir,
+		serverDir: nitro.graphql.serverDir,
+		clientDir: nitro.graphql.clientDir,
+		ignorePatterns: nitro.options.ignore,
+		isDev: nitro.options.dev,
+		logger: createLoggerFromNitro(nitro),
+		layerServerDirs: nitro.options.graphql?.layerServerDirs || [],
+		layerAppDirs: nitro.options.graphql?.layerAppDirs || []
+	};
+}
+/**
+* Create a CoreConfig from Nitro instance
+*/
+function createCoreConfigFromNitro(nitro) {
+	const graphqlOptions = nitro.options.graphql || {};
+	const isNuxt = nitro.options.framework?.name === "nuxt";
+	const typesDir = join(nitro.graphql.buildDir, "types");
+	return {
+		rootDir: nitro.options.rootDir,
+		buildDir: nitro.graphql.buildDir,
+		serverDir: nitro.graphql.serverDir,
+		clientDir: nitro.graphql.clientDir,
+		typesDir,
+		framework: graphqlOptions.framework || "graphql-yoga",
+		isNuxt,
+		isDev: nitro.options.dev,
+		graphqlOptions: {
+			framework: graphqlOptions.framework,
+			endpoint: typeof graphqlOptions.endpoint === "object" ? graphqlOptions.endpoint?.graphql : graphqlOptions.endpoint,
+			federation: graphqlOptions.federation,
+			security: graphqlOptions.security
+		},
+		logger: createLoggerFromNitro(nitro),
+		ignorePatterns: nitro.options.ignore,
+		layerServerDirs: nitro.options.graphql?.layerServerDirs || [],
+		layerAppDirs: nitro.options.graphql?.layerAppDirs || []
+	};
+}
+/**
+* Create a CoreContext from Nitro instance
+*/
+function createCoreContextFromNitro(nitro) {
+	return {
+		config: createCoreConfigFromNitro(nitro),
+		graphqlBuildDir: nitro.graphql.buildDir,
+		watchDirs: nitro.graphql.watchDirs,
+		dir: nitro.graphql.dir
+	};
+}
+/**
+* Nitro framework adapter implementation
+*/
+const NitroAdapter = {
+	name: "nitro",
+	createCoreConfig: createCoreConfigFromNitro,
+	createCoreContext: createCoreContextFromNitro,
+	createScanContext: createScanContextFromNitro,
+	getLogger: createLoggerFromNitro,
+	scanSchemas: (nitro) => scanSchemasCore(createScanContextFromNitro(nitro)),
+	scanGraphql: (nitro) => scanGraphqlCore(createScanContextFromNitro(nitro)),
+	scanResolvers: (nitro) => scanResolversCore(createScanContextFromNitro(nitro)),
+	scanDirectives: (nitro) => scanDirectivesCore(createScanContextFromNitro(nitro)),
+	scanDocuments(nitro) {
+		return scanDocumentsCore(createScanContextFromNitro(nitro), {
+			externalServices: nitro.options.graphql?.externalServices,
+			clientDirRelative: relative(nitro.options.rootDir, nitro.graphql.clientDir)
+		});
+	}
+};
+var adapter_default = NitroAdapter;
+
+//#endregion
+export { NitroAdapter, createCoreConfigFromNitro, createCoreContextFromNitro, createLoggerFromNitro, createScanContextFromNitro, adapter_default as default };

package/dist/{utils → nitro}/apollo.d.mts

@@ -2,7 +2,7 @@ import { ApolloServer, BaseContext, ContextFunction } from "@apollo/server";
 import { EventHandler, H3Event } from "nitro/h3";
 import { Hooks } from "crossws";
 
-//#region src/utils/apollo.d.ts
+//#region src/nitro/apollo.d.ts
 type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
 interface H3ContextFunctionArgument {
   event: H3Event;

package/dist/{utils → nitro}/apollo.mjs

@@ -1,7 +1,7 @@
 import { HeaderMap } from "@apollo/server";
 import { eventHandler, getRequestURL, readBody } from "nitro/h3";
 
-//#region src/utils/apollo.ts
+//#region src/nitro/apollo.ts
 function startServerAndCreateH3Handler(server, options) {
 	const defaultContext = () => Promise.resolve({});
 	const contextFunction = options?.context ?? defaultContext;

package/dist/nitro/codegen.d.mts

@@ -0,0 +1,19 @@
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/codegen.d.ts
+
+/**
+ * Generate server-side resolver types
+ */
+declare function generateServerTypes(nitro: Nitro, options?: {
+  silent?: boolean;
+}): Promise<void>;
+/**
+ * Generate client-side operation types
+ */
+declare function generateClientTypes(nitro: Nitro, options?: {
+  silent?: boolean;
+  isInitial?: boolean;
+}): Promise<void>;
+//#endregion
+export { generateClientTypes, generateServerTypes };

package/dist/nitro/codegen.mjs

@@ -0,0 +1,141 @@
+import { LOG_TAG } from "../core/constants.mjs";
+import { loadGraphQLDocuments } from "../core/codegen/document-loader.mjs";
+import { writeFile } from "../core/utils/file-io.mjs";
+import { downloadAndSaveSchema, loadExternalSchema } from "../core/codegen/schema-loader.mjs";
+import { generateClientTypesCore, generateExternalClientTypesCore } from "../core/codegen/client.mjs";
+import { generateServerTypesCore } from "../core/codegen/server.mjs";
+import { validateNoDuplicateTypes } from "../core/codegen/validation.mjs";
+import { loadFederationSupport } from "../core/schema/federation.mjs";
+import { getDefaultPaths, getSdkConfig, getTypesConfig, resolveFilePath, shouldGenerateTypes } from "./paths.mjs";
+import consola from "consola";
+import { join, resolve } from "pathe";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { buildSchema, parse, print } from "graphql";
+import { existsSync, readFileSync } from "node:fs";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+import { loadFilesSync } from "@graphql-tools/load-files";
+
+//#region src/nitro/codegen.ts
+const logger = consola.withTag(LOG_TAG);
+async function buildSchemaFromString(source, federation) {
+	if (federation) {
+		const buildSubgraph = await loadFederationSupport();
+		if (!buildSubgraph) throw new Error("Federation enabled but @apollo/subgraph not installed");
+		return buildSubgraph([{ typeDefs: parse(source) }]);
+	}
+	return buildSchema(source);
+}
+/**
+* Generate server-side resolver types
+*/
+async function generateServerTypes(nitro, options = {}) {
+	if (!shouldGenerateTypes(nitro)) return;
+	const schemas = nitro.scanSchemas || [];
+	if (!schemas.length) {
+		if (!options.silent) consola.info("No GraphQL schemas found");
+		return;
+	}
+	try {
+		const strings = loadFilesSync(schemas).map((s) => typeof s === "string" ? s : s.loc?.source?.body || "").filter(Boolean);
+		if (!validateNoDuplicateTypes(schemas, strings)) return;
+		const merged = mergeTypeDefs([strings.join("\n\n")], { throwOnConflict: true });
+		const federation = nitro.options.graphql?.federation?.enabled === true;
+		const schema = await buildSchemaFromString(print(merged), federation);
+		const result = await generateServerTypesCore({
+			framework: nitro.options.graphql?.framework || "graphql-yoga",
+			schema,
+			config: nitro.options.graphql?.codegen?.server,
+			federationEnabled: federation
+		});
+		writeFile(resolve(nitro.graphql.buildDir, "schema.graphql"), printSchemaWithDirectives(schema));
+		const placeholders = getDefaultPaths(nitro);
+		const typesConfig = getTypesConfig(nitro);
+		const typesPath = resolveFilePath(typesConfig.server, typesConfig.enabled, true, "{typesDir}/nitro-graphql-server.d.ts", placeholders);
+		if (typesPath) {
+			writeFile(typesPath, result.types);
+			if (!options.silent) logger.success(`Server types: ${typesPath}`);
+		}
+	} catch (error) {
+		logger.error("Server type generation failed:", error);
+	}
+}
+/**
+* Generate client-side operation types
+*/
+async function generateClientTypes(nitro, options = {}) {
+	try {
+		if (nitro.scanSchemas?.length) await generateMainClientTypes(nitro, options);
+		if (nitro.options.graphql?.externalServices?.length) await generateExternalTypes(nitro, options);
+	} catch (error) {
+		logger.error("Client type generation failed:", error);
+	}
+}
+async function generateMainClientTypes(nitro, options = {}) {
+	const schemaPath = join(nitro.graphql.buildDir, "schema.graphql");
+	if (!existsSync(schemaPath)) {
+		if (!options.silent) consola.info("Schema not ready for client types");
+		return;
+	}
+	const docs = await loadGraphQLDocuments(nitro.scanDocuments);
+	const federation = nitro.options.graphql?.federation?.enabled === true;
+	const types = await generateClientTypesCore({
+		schema: await buildSchemaFromString(readFileSync(schemaPath, "utf-8"), federation),
+		documents: docs,
+		config: nitro.options.graphql?.codegen?.client,
+		sdkConfig: nitro.options.graphql?.codegen?.clientSDK,
+		options
+	});
+	if (types === false) return;
+	const placeholders = getDefaultPaths(nitro);
+	const typesConfig = getTypesConfig(nitro);
+	const sdkConfig = getSdkConfig(nitro);
+	const clientPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
+	if (clientPath) {
+		writeFile(clientPath, types.types);
+		if (!options.silent) logger.success(`Client types: ${clientPath}`);
+	}
+	const sdkPath = resolveFilePath(sdkConfig.main, sdkConfig.enabled, true, "{clientGraphql}/default/sdk.ts", placeholders);
+	if (sdkPath) {
+		writeFile(sdkPath, types.sdk);
+		if (!options.silent) logger.success(`SDK: ${sdkPath}`);
+	}
+}
+async function generateExternalTypes(nitro, options = {}) {
+	for (const service of nitro.options.graphql?.externalServices || []) try {
+		if (!options.silent) consola.info(`[${service.name}] Processing external service`);
+		await downloadAndSaveSchema(service, nitro.options.buildDir);
+		const schema = await loadExternalSchema(service, nitro.options.buildDir);
+		if (!schema) {
+			consola.warn(`[${service.name}] Failed to load schema`);
+			continue;
+		}
+		const docs = service.documents?.length ? await loadGraphQLDocuments(service.documents).catch(() => []) : [];
+		if (service.documents?.length && !docs.length) {
+			consola.warn(`[${service.name}] No documents found`);
+			continue;
+		}
+		const types = await generateExternalClientTypesCore(service, schema, docs);
+		if (types === false) continue;
+		const placeholders = {
+			...getDefaultPaths(nitro),
+			serviceName: service.name
+		};
+		const typesConfig = getTypesConfig(nitro);
+		const sdkConfig = getSdkConfig(nitro);
+		const typesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", placeholders);
+		if (typesPath) {
+			writeFile(typesPath, types.types);
+			if (!options.silent) consola.success(`[${service.name}] Types: ${typesPath}`);
+		}
+		const sdkPath = resolveFilePath(service.paths?.sdk ?? sdkConfig.external, sdkConfig.enabled, true, "{clientGraphql}/{serviceName}/sdk.ts", placeholders);
+		if (sdkPath) {
+			writeFile(sdkPath, types.sdk);
+			if (!options.silent) consola.success(`[${service.name}] SDK: ${sdkPath}`);
+		}
+	} catch (error) {
+		consola.error(`[${service.name}] External service failed:`, error);
+	}
+}
+
+//#endregion
+export { generateClientTypes, generateServerTypes };

package/dist/nitro/config.d.mts

@@ -0,0 +1,52 @@
+import { NitroGraphQLOptions } from "./types.mjs";
+
+//#region src/nitro/config.d.ts
+
+/**
+ * Default type generation configuration
+ */
+declare const DEFAULT_TYPES_CONFIG: {
+  readonly server: ".graphql/nitro-graphql-server.d.ts";
+  readonly client: ".graphql/nitro-graphql-client.d.ts";
+  readonly enabled: true;
+};
+/**
+ * Default runtime GraphQL configuration
+ */
+declare const DEFAULT_RUNTIME_CONFIG: NitroGraphQLOptions;
+/**
+ * Default ignore patterns for file watching
+ */
+declare const DEFAULT_IGNORE_PATTERNS: string[];
+/**
+ * Default SDK configuration
+ */
+declare const DEFAULT_SDK_CONFIG: {
+  readonly enabled: true;
+  readonly main: true;
+  readonly external: true;
+};
+/**
+ * Default paths configuration
+ * These are used as placeholders and resolved based on framework
+ */
+declare const DEFAULT_PATHS_CONFIG: {
+  readonly serverGraphql: "server/graphql";
+  readonly clientGraphql: null;
+  readonly buildDir: null;
+  readonly typesDir: null;
+};
+/**
+ * Default TypeScript strict mode setting
+ */
+declare const DEFAULT_TYPESCRIPT_STRICT: true;
+/**
+ * Default watcher persistence setting
+ */
+declare const DEFAULT_WATCHER_PERSISTENT: true;
+/**
+ * Default watcher ignore initial setting
+ */
+declare const DEFAULT_WATCHER_IGNORE_INITIAL: true;
+//#endregion
+export { DEFAULT_IGNORE_PATTERNS, DEFAULT_PATHS_CONFIG, DEFAULT_RUNTIME_CONFIG, DEFAULT_SDK_CONFIG, DEFAULT_TYPESCRIPT_STRICT, DEFAULT_TYPES_CONFIG, DEFAULT_WATCHER_IGNORE_INITIAL, DEFAULT_WATCHER_PERSISTENT };

package/dist/nitro/config.mjs

@@ -0,0 +1,58 @@
+import { DEFAULT_CLIENT_TYPES_PATH, DEFAULT_SERVER_TYPES_PATH, ENDPOINT_GRAPHQL, ENDPOINT_HEALTH } from "../core/constants.mjs";
+
+//#region src/nitro/config.ts
+/**
+* Default type generation configuration
+*/
+const DEFAULT_TYPES_CONFIG = {
+	server: DEFAULT_SERVER_TYPES_PATH,
+	client: DEFAULT_CLIENT_TYPES_PATH,
+	enabled: true
+};
+/**
+* Default runtime GraphQL configuration
+*/
+const DEFAULT_RUNTIME_CONFIG = {
+	endpoint: {
+		graphql: ENDPOINT_GRAPHQL,
+		healthCheck: ENDPOINT_HEALTH
+	},
+	playground: true
+};
+/**
+* Default ignore patterns for file watching
+*/
+const DEFAULT_IGNORE_PATTERNS = [];
+/**
+* Default SDK configuration
+*/
+const DEFAULT_SDK_CONFIG = {
+	enabled: true,
+	main: true,
+	external: true
+};
+/**
+* Default paths configuration
+* These are used as placeholders and resolved based on framework
+*/
+const DEFAULT_PATHS_CONFIG = {
+	serverGraphql: "server/graphql",
+	clientGraphql: null,
+	buildDir: null,
+	typesDir: null
+};
+/**
+* Default TypeScript strict mode setting
+*/
+const DEFAULT_TYPESCRIPT_STRICT = true;
+/**
+* Default watcher persistence setting
+*/
+const DEFAULT_WATCHER_PERSISTENT = true;
+/**
+* Default watcher ignore initial setting
+*/
+const DEFAULT_WATCHER_IGNORE_INITIAL = true;
+
+//#endregion
+export { DEFAULT_IGNORE_PATTERNS, DEFAULT_PATHS_CONFIG, DEFAULT_RUNTIME_CONFIG, DEFAULT_SDK_CONFIG, DEFAULT_TYPESCRIPT_STRICT, DEFAULT_TYPES_CONFIG, DEFAULT_WATCHER_IGNORE_INITIAL, DEFAULT_WATCHER_PERSISTENT };

package/dist/nitro/index.d.mts

@@ -0,0 +1,46 @@
+import { CodegenClientConfig, CodegenServerConfig, DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, ExtendSource, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, Flatten, GenImport, GenericSdkConfig, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, NitroGraphQLOptions, PathsConfig, SdkConfig, SecurityConfig, StandardSchemaV1, TypesConfig } from "./types.mjs";
+import { NitroAdapter } from "./adapter.mjs";
+import { resolveSecurityConfig } from "./setup/logging.mjs";
+import { setupNitroGraphQL } from "./setup.mjs";
+import { NitroModule } from "nitro/types";
+import { Plugin } from "vite";
+
+//#region src/nitro/index.d.ts
+
+/**
+ * Vite plugin to load GraphQL files as strings AND auto-register Nitro module
+ * This prevents Vite from trying to parse .graphql/.gql files as JavaScript
+ * and automatically sets up the nitro-graphql module via the nitro: hook
+ *
+ * @example - Vite usage
+ * ```ts
+ * import { defineConfig } from 'vite'
+ * import { nitro } from 'nitro/vite'
+ * import graphql from 'nitro-graphql'
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     graphql({ framework: 'graphql-yoga' }), // Auto-registers Nitro module
+ *     nitro()
+ *   ]
+ * })
+ * ```
+ *
+ *
+ * @example - Nitro direct usage
+ * ```ts
+ *
+ * import graphql from 'nitro-graphql'
+ *
+ * export default defineConfig({
+ *   modules: [
+ *    graphql({ framework: 'graphql-yoga' }) // Auto-registers Nitro module
+ *   ]
+ * })
+ * ```
+ */
+declare function graphqlModule(options?: NitroGraphQLOptions): Plugin & {
+  nitro?: NitroModule;
+};
+//#endregion
+export { CodegenClientConfig, CodegenServerConfig, DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, ExtendSource, ExternalGraphQLService, ExternalServicePaths, FederationConfig, FileGenerationConfig, Flatten, GenImport, GenericSdkConfig, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, NitroAdapter, NitroGraphQLOptions, PathsConfig, SdkConfig, SecurityConfig, StandardSchemaV1, TypesConfig, graphqlModule as default, resolveSecurityConfig, setupNitroGraphQL };