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

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

@@ -0,0 +1,128 @@
+import { writeFile } from "../utils/file-io.mjs";
+import { resolve } from "pathe";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
+import { loadSchemaSync } from "@graphql-tools/load";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { UrlLoader } from "@graphql-tools/url-loader";
+
+//#region src/core/codegen/schema-loader.ts
+/**
+* Check if a path is a URL
+*/
+function isUrl(path) {
+	return path.startsWith("http://") || path.startsWith("https://");
+}
+/**
+* Load GraphQL schema synchronously
+*/
+function graphQLLoadSchemaSync(schemaPointers, data = {}) {
+	const filteredPointers = [...Array.isArray(schemaPointers) ? schemaPointers : [schemaPointers], "!**/vfs/**"];
+	try {
+		return 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:")) return;
+		throw e;
+	}
+}
+/**
+* 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 {}
+		}
+		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 {
+		return;
+	}
+}
+/**
+* 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;
+			} catch {
+				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 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) {
+			let schema;
+			if (hasUrlSchemas && hasLocalSchemas) schema = loadSchemaSync(schemas, {
+				loaders: [new GraphQLFileLoader(), new UrlLoader()],
+				...Object.keys(headers).length > 0 && { headers }
+			});
+			else if (hasUrlSchemas) schema = loadSchemaSync(schemas, {
+				loaders: [new UrlLoader()],
+				...Object.keys(headers).length > 0 && { headers }
+			});
+			else schema = loadSchemaSync(schemas, { loaders: [new GraphQLFileLoader()] });
+			writeFile(schemaFilePath, printSchemaWithDirectives(schema));
+		}
+		return schemaFilePath;
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+export { downloadAndSaveSchema, graphQLLoadSchemaSync, loadExternalSchema };

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

@@ -0,0 +1,28 @@
+import { ServerCodegenConfig, ServerCodegenInput, ServerCodegenResult } from "../types/codegen.mjs";
+import { GraphQLSchema } from "graphql";
+
+//#region src/core/codegen/server.d.ts
+
+/**
+ * Default server codegen configuration
+ */
+declare const DEFAULT_SERVER_CODEGEN_CONFIG: ServerCodegenConfig;
+/**
+ * Generate server-side GraphQL types
+ * Pure function that generates TypeScript types from a GraphQL schema
+ */
+declare function generateServerTypesCore(input: ServerCodegenInput): Promise<ServerCodegenResult>;
+/**
+ * Generate types from schema (simplified version for direct use)
+ * @deprecated Use generateServerTypesCore instead
+ */
+declare function generateTypes(framework: string, schema: GraphQLSchema, config?: {
+  codegen?: {
+    server?: ServerCodegenConfig;
+  };
+  federation?: {
+    enabled?: boolean;
+  };
+}, outputPath?: string): Promise<string>;
+//#endregion
+export { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore, generateTypes };

package/dist/core/codegen/server.mjs

@@ -0,0 +1,143 @@
+import { DEFAULT_GRAPHQL_SCALARS } from "../constants.mjs";
+import { pluginContent } from "./plugin.mjs";
+import { defu as defu$1 } from "defu";
+import { codegen } from "@graphql-codegen/core";
+import * as typescriptPlugin from "@graphql-codegen/typescript";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { parse } from "graphql";
+import * as typescriptResolversPlugin from "@graphql-codegen/typescript-resolvers";
+
+//#region src/core/codegen/server.ts
+/**
+* Default server codegen configuration
+*/
+const DEFAULT_SERVER_CODEGEN_CONFIG = {
+	scalars: DEFAULT_GRAPHQL_SCALARS,
+	defaultScalarType: "unknown",
+	defaultMapper: `ResolverReturnType<{T}>`,
+	contextType: "nitro/h3#H3Event",
+	maybeValue: "T | null | undefined",
+	inputMaybeValue: "T | undefined",
+	declarationKind: "interface",
+	enumsAsTypes: true
+};
+/**
+* Generate server-side GraphQL types
+* Pure function that generates TypeScript types from a GraphQL schema
+*/
+async function generateServerTypesCore(input) {
+	const { framework, schema, config = {}, federationEnabled = false, outputPath } = input;
+	const mergedConfig = defu$1({
+		...DEFAULT_SERVER_CODEGEN_CONFIG,
+		...federationEnabled && { federation: true }
+	}, config);
+	const schemaString = printSchemaWithDirectives(schema);
+	return {
+		types: await codegen({
+			filename: outputPath || "types.generated.ts",
+			schema: parse(schemaString),
+			documents: [],
+			config: mergedConfig,
+			plugins: [
+				{ imports: {} },
+				{ pluginContent: {} },
+				{ typescript: {} },
+				{ typescriptResolvers: {} }
+			],
+			pluginMap: {
+				pluginContent: { plugin: pluginContent },
+				imports: { plugin: () => {
+					return {
+						prepend: [
+							`import schemas from '#graphql/schema'`,
+							`import type { StandardSchemaV1 } from 'nitro-graphql/types'`,
+							generateServerTypeHelpers(framework),
+							""
+						],
+						content: ""
+					};
+				} },
+				typescript: typescriptPlugin,
+				typescriptResolvers: typescriptResolversPlugin
+			}
+		}),
+		schemaString
+	};
+}
+/**
+* Generate server type helper code
+*/
+function generateServerTypeHelpers(framework) {
+	return `
+export interface NPMConfig {
+  framework: '${framework || "graphql-yoga"}';
+}
+
+export type SchemaType = Partial<Record<Partial<keyof ResolversTypes>, StandardSchemaV1>>
+
+// Check if schemas is empty object, return never if so
+type SafeSchemaKeys<T> = T extends Record<PropertyKey, never>
+  ? never
+  : keyof T extends string | number | symbol
+    ? keyof T extends never
+      ? never
+      : keyof T
+    : never;
+
+
+type SchemaKeys = SafeSchemaKeys<typeof schemas>;
+
+type InferInput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferInput<T> : unknown;
+type InferOutput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<T> : unknown;
+
+type InferInputFromSchema<T extends SchemaKeys> = InferInput<(typeof schemas)[T]>;
+type InferOutputFromSchema<T extends SchemaKeys> = InferOutput<(typeof schemas)[T]>;
+
+type Primitive =
+| null
+| undefined
+| string
+| number
+| boolean
+| symbol
+| bigint;
+
+type BuiltIns = Primitive | void | Date | RegExp;
+
+
+type ResolverReturnType<T> = T extends BuiltIns
+? T
+: T extends (...args: any[]) => unknown
+? T | undefined
+: T extends object
+? T extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+  ? ItemType[] extends T // Test for arrays (non-tuples) specifically
+    ? Array<ResolverReturnType<ItemType>>
+    : ResolverReturnTypeObject<T> // Tuples behave properly
+  : ResolverReturnTypeObject<T>
+: unknown;
+
+type ResolverReturnTypeObject<T extends object> =
+  T extends { __typename?: infer TTypename }
+    ? TTypename extends SchemaKeys
+      ? InferOutputFromSchema<TTypename>
+      : { [K in keyof T]: ResolverReturnType<T[K]> }
+    : { [K in keyof T]: ResolverReturnType<T[K]> };
+`;
+}
+/**
+* Generate types from schema (simplified version for direct use)
+* @deprecated Use generateServerTypesCore instead
+*/
+async function generateTypes(framework, schema, config = {}, outputPath) {
+	return (await generateServerTypesCore({
+		framework,
+		schema,
+		config: config.codegen?.server,
+		federationEnabled: config.federation?.enabled,
+		outputPath
+	})).types;
+}
+
+//#endregion
+export { DEFAULT_SERVER_CODEGEN_CONFIG, generateServerTypesCore, generateTypes };

package/dist/{codegen → core/codegen}/validation.d.mts

@@ -1,4 +1,4 @@
-//#region src/codegen/validation.d.ts
+//#region src/core/codegen/validation.d.ts
 /**
  * GraphQL schema validation utilities
  * Validates schemas for duplicate type definitions and conflicts

package/dist/{codegen → core/codegen}/validation.mjs

@@ -4,7 +4,7 @@ import { basename } from "pathe";
 import { parse } from "graphql";
 import { mergeTypeDefs } from "@graphql-tools/merge";
 
-//#region src/codegen/validation.ts
+//#region src/core/codegen/validation.ts
 /**
 * GraphQL schema validation utilities
 * Validates schemas for duplicate type definitions and conflicts

package/dist/core/config.d.mts

@@ -0,0 +1,50 @@
+import { CoreConfig, CoreContext, CoreGraphQLOptions, CoreLogger } from "./types/config.mjs";
+import { ScanContext } from "./types/scanning.mjs";
+
+//#region src/core/config.d.ts
+
+/**
+ * Options for creating a CoreConfig
+ */
+interface CreateCoreConfigOptions {
+  /** Root directory of the project */
+  rootDir: string;
+  /** Build directory (optional, defaults based on framework) */
+  buildDir?: string;
+  /** Server GraphQL directory (optional) */
+  serverDir?: string;
+  /** Client GraphQL directory (optional) */
+  clientDir?: string;
+  /** Whether running in Nuxt context */
+  isNuxt?: boolean;
+  /** Whether running in development mode */
+  isDev?: boolean;
+  /** GraphQL options */
+  graphqlOptions?: CoreGraphQLOptions;
+  /** Custom logger */
+  logger?: CoreLogger;
+  /** Patterns to ignore */
+  ignorePatterns?: string[];
+  /** Layer server directories */
+  layerServerDirs?: string[];
+  /** Layer app directories */
+  layerAppDirs?: string[];
+}
+/**
+ * Create a CoreConfig with sensible defaults
+ */
+declare function createCoreConfig(options: CreateCoreConfigOptions): CoreConfig;
+/**
+ * Create a CoreContext from CoreConfig
+ */
+declare function createCoreContext(config: CoreConfig): CoreContext;
+/**
+ * Create a ScanContext from CoreConfig
+ */
+declare function createScanContext(config: CoreConfig): ScanContext;
+/**
+ * Merge GraphQL options with defaults
+ */
+declare function mergeGraphQLOptions(options: Partial<CoreGraphQLOptions>, defaults?: Partial<CoreGraphQLOptions>): CoreGraphQLOptions;
+//#endregion
+export { CreateCoreConfigOptions, createCoreConfig, createCoreContext, createScanContext, mergeGraphQLOptions };

package/dist/core/config.mjs

@@ -0,0 +1,82 @@
+import { DIR_APP_GRAPHQL, DIR_BUILD_NITRO, DIR_CLIENT_GRAPHQL, DIR_SERVER_GRAPHQL, GRAPHQL_FRAMEWORK_YOGA } from "./constants.mjs";
+import { createLogger } from "./utils/logger.mjs";
+import { relative, resolve } from "pathe";
+
+//#region src/core/config.ts
+/**
+* Create a CoreConfig with sensible defaults
+*/
+function createCoreConfig(options) {
+	const { rootDir, isNuxt = false, isDev = process.env.NODE_ENV !== "production", graphqlOptions = {}, logger = createLogger(), ignorePatterns = [], layerServerDirs = [], layerAppDirs = [] } = options;
+	const framework = graphqlOptions.framework || GRAPHQL_FRAMEWORK_YOGA;
+	const buildDir = options.buildDir || resolve(rootDir, isNuxt ? ".nuxt" : DIR_BUILD_NITRO);
+	return {
+		rootDir,
+		buildDir,
+		serverDir: options.serverDir || resolve(rootDir, DIR_SERVER_GRAPHQL),
+		clientDir: options.clientDir || resolve(rootDir, isNuxt ? DIR_APP_GRAPHQL : DIR_CLIENT_GRAPHQL),
+		typesDir: resolve(buildDir, "types"),
+		framework,
+		isNuxt,
+		isDev,
+		graphqlOptions,
+		logger,
+		ignorePatterns,
+		layerServerDirs,
+		layerAppDirs
+	};
+}
+/**
+* Create a CoreContext from CoreConfig
+*/
+function createCoreContext(config) {
+	return {
+		config,
+		graphqlBuildDir: resolve(config.buildDir, "graphql"),
+		watchDirs: [],
+		dir: {
+			build: relative(config.rootDir, config.buildDir),
+			client: relative(config.rootDir, config.clientDir),
+			server: relative(config.rootDir, config.serverDir)
+		}
+	};
+}
+/**
+* Create a ScanContext from CoreConfig
+*/
+function createScanContext(config) {
+	return {
+		rootDir: config.rootDir,
+		serverDir: config.serverDir,
+		clientDir: config.clientDir,
+		ignorePatterns: config.ignorePatterns,
+		isDev: config.isDev,
+		logger: config.logger,
+		layerServerDirs: config.layerServerDirs,
+		layerAppDirs: config.layerAppDirs
+	};
+}
+/**
+* Merge GraphQL options with defaults
+*/
+function mergeGraphQLOptions(options, defaults = {}) {
+	return {
+		...defaults,
+		...options,
+		codegen: {
+			...defaults.codegen,
+			...options.codegen
+		},
+		security: {
+			...defaults.security,
+			...options.security
+		},
+		paths: {
+			...defaults.paths,
+			...options.paths
+		}
+	};
+}
+
+//#endregion
+export { createCoreConfig, createCoreContext, createScanContext, mergeGraphQLOptions };

package/dist/core/constants.d.mts

@@ -0,0 +1,188 @@
+//#region src/core/constants.d.ts
+/**
+ * Constants and magic strings used throughout nitro-graphql core
+ * Centralizing these values prevents typos and makes refactoring easier
+ */
+/**
+ * Default scalar type mappings for GraphQL codegen
+ * These scalars are commonly used and have proper TypeScript type mappings
+ */
+declare const DEFAULT_GRAPHQL_SCALARS: {
+  readonly DateTime: string;
+  readonly DateTimeISO: string;
+  readonly UUID: string;
+  readonly JSON: string;
+  readonly JSONObject: string;
+  readonly NonEmptyString: string;
+  readonly Currency: string;
+  readonly File: {
+    readonly input: "File";
+    readonly output: "File";
+  };
+};
+/**
+ * GraphQL schema file extensions
+ */
+declare const GRAPHQL_EXTENSIONS: readonly [".graphql", ".gql"];
+/**
+ * Resolver file extensions
+ */
+declare const RESOLVER_EXTENSIONS: readonly [".resolver.ts", ".resolver.js"];
+/**
+ * Directive file extensions
+ */
+declare const DIRECTIVE_EXTENSIONS: readonly [".directive.ts", ".directive.js"];
+/**
+ * Combined pattern for glob scanning
+ */
+declare const GLOB_SCAN_PATTERN: "**/*.{graphql,gql,js,mjs,cjs,ts,mts,cts,tsx,jsx}";
+/**
+ * GraphQL file pattern for glob
+ */
+declare const GRAPHQL_GLOB_PATTERN: "**/*.graphql";
+/**
+ * Resolver file pattern for glob
+ */
+declare const RESOLVER_GLOB_PATTERN: "**/*.resolver.{ts,js}";
+/**
+ * Directive file pattern for glob
+ */
+declare const DIRECTIVE_GLOB_PATTERN: "**/*.directive.{ts,js}";
+/**
+ * Framework names
+ */
+declare const FRAMEWORK_NUXT: "nuxt";
+declare const FRAMEWORK_NITRO: "nitro";
+declare const FRAMEWORK_STANDALONE: "standalone";
+/**
+ * GraphQL server framework identifiers
+ */
+declare const GRAPHQL_FRAMEWORK_YOGA: "graphql-yoga";
+declare const GRAPHQL_FRAMEWORK_APOLLO: "apollo-server";
+type Framework = typeof FRAMEWORK_NUXT | typeof FRAMEWORK_NITRO | typeof FRAMEWORK_STANDALONE;
+type GraphQLFramework = typeof GRAPHQL_FRAMEWORK_YOGA | typeof GRAPHQL_FRAMEWORK_APOLLO;
+/**
+ * Default directory names for GraphQL files
+ */
+declare const DIR_SERVER_GRAPHQL: "server/graphql";
+declare const DIR_ROUTES_GRAPHQL: "routes/graphql";
+declare const DIR_APP_GRAPHQL: "app/graphql";
+declare const DIR_CLIENT_GRAPHQL: "graphql";
+declare const DIR_EXTERNAL: "external";
+/**
+ * Windows-compatible server GraphQL directory
+ */
+declare const DIR_SERVER_GRAPHQL_WIN: "server\\graphql";
+/**
+ * Build directory names
+ */
+declare const DIR_BUILD_NITRO: ".nitro";
+declare const DIR_BUILD_NUXT: ".nuxt";
+/**
+ * Default GraphQL endpoint paths
+ */
+declare const ENDPOINT_GRAPHQL: "/api/graphql";
+declare const ENDPOINT_HEALTH: "/api/graphql/health";
+declare const ENDPOINT_DEBUG: "/_nitro/graphql/debug";
+/**
+ * Configuration and scaffold file names
+ */
+declare const FILE_GRAPHQL_CONFIG: "graphql.config.ts";
+declare const FILE_SCHEMA_GRAPHQL: "schema.graphql";
+declare const FILE_SCHEMA_TS: "schema.ts";
+declare const FILE_CONFIG_TS: "config.ts";
+declare const FILE_CONTEXT_DTS: "context.d.ts";
+declare const FILE_CONTEXT_TS: "context.ts";
+declare const FILE_INDEX_TS: "index.ts";
+declare const FILE_OFETCH_TS: "ofetch.ts";
+declare const FILE_SDK_TS: "sdk.ts";
+declare const FILE_DIRECTIVES_GRAPHQL: "_directives.graphql";
+/**
+ * Generated type definition file names
+ */
+declare const FILE_SERVER_TYPES: "nitro-graphql-server.d.ts";
+declare const FILE_CLIENT_TYPES: "nitro-graphql-client.d.ts";
+declare const FILE_GRAPHQL_DTS: "graphql.d.ts";
+/**
+ * Generated type file name patterns with placeholders
+ */
+declare const PATTERN_CLIENT_EXTERNAL_TYPES: "nitro-graphql-client-{serviceName}.d.ts";
+/**
+ * Rollup/Rolldown chunk output paths
+ */
+declare const CHUNK_PATH_GRAPHQL: "chunks/graphql/[name].mjs";
+declare const CHUNK_PATH_UNKNOWN: "chunks/_/[name].mjs";
+/**
+ * Default chunk names
+ */
+declare const CHUNK_NAME_SCHEMAS: "schemas";
+declare const CHUNK_NAME_RESOLVERS: "resolvers";
+/**
+ * Valid define function names for resolver exports
+ */
+declare const DEFINE_FUNCTIONS: readonly ["defineResolver", "defineQuery", "defineMutation", "defineField", "defineSubscription", "defineDirective"];
+declare const DEFINE_RESOLVER: "defineResolver";
+declare const DEFINE_QUERY: "defineQuery";
+declare const DEFINE_MUTATION: "defineMutation";
+declare const DEFINE_FIELD: "defineField";
+declare const DEFINE_SUBSCRIPTION: "defineSubscription";
+declare const DEFINE_DIRECTIVE: "defineDirective";
+declare const DEFINE_GRAPHQL_CONFIG: "defineGraphQLConfig";
+declare const DEFINE_SCHEMA: "defineSchema";
+type DefineFunction = typeof DEFINE_FUNCTIONS[number];
+/**
+ * Built-in GraphQL scalar types (should not be flagged as duplicates)
+ */
+declare const BUILTIN_SCALARS: readonly ["String", "Int", "Float", "Boolean", "ID", "DateTime", "JSON"];
+/**
+ * Codegen parser dependencies (always external)
+ */
+declare const CODEGEN_EXTERNALS: readonly ["oxc-parser", "@oxc-parser"];
+/**
+ * Apollo Federation dependencies (external when federation disabled)
+ */
+declare const FEDERATION_EXTERNALS: readonly ["@apollo/subgraph", "@apollo/federation-internals", "@apollo/cache-control-types"];
+/**
+ * Supported HTTP methods for GraphQL endpoints
+ */
+declare const GRAPHQL_HTTP_METHODS: readonly ["GET", "POST", "OPTIONS"];
+/**
+ * Default paths for type generation (relative to buildDir)
+ */
+declare const DEFAULT_SERVER_TYPES_PATH: ".graphql/nitro-graphql-server.d.ts";
+declare const DEFAULT_CLIENT_TYPES_PATH: ".graphql/nitro-graphql-client.d.ts";
+/**
+ * Valid resolver export types detected from AST parsing
+ */
+declare const RESOLVER_TYPE_QUERY: "query";
+declare const RESOLVER_TYPE_MUTATION: "mutation";
+declare const RESOLVER_TYPE_RESOLVER: "resolver";
+declare const RESOLVER_TYPE_TYPE: "type";
+declare const RESOLVER_TYPE_SUBSCRIPTION: "subscription";
+declare const RESOLVER_TYPE_DIRECTIVE: "directive";
+type ResolverType = typeof RESOLVER_TYPE_QUERY | typeof RESOLVER_TYPE_MUTATION | typeof RESOLVER_TYPE_RESOLVER | typeof RESOLVER_TYPE_TYPE | typeof RESOLVER_TYPE_SUBSCRIPTION | typeof RESOLVER_TYPE_DIRECTIVE;
+/**
+ * Placeholder strings used in path resolution
+ */
+declare const PLACEHOLDER_SERVICE_NAME: "{serviceName}";
+declare const PLACEHOLDER_BUILD_DIR: "{buildDir}";
+declare const PLACEHOLDER_ROOT_DIR: "{rootDir}";
+declare const PLACEHOLDER_FRAMEWORK: "{framework}";
+declare const PLACEHOLDER_TYPES_DIR: "{typesDir}";
+declare const PLACEHOLDER_SERVER_GRAPHQL: "{serverGraphql}";
+declare const PLACEHOLDER_CLIENT_GRAPHQL: "{clientGraphql}";
+/**
+ * Logger tag for nitro-graphql module
+ */
+declare const LOG_TAG: "nitro-graphql";
+/**
+ * HTTP status codes for error handling
+ */
+declare const HTTP_STATUS_BAD_REQUEST: 400;
+declare const HTTP_STATUS_INTERNAL_ERROR: 500;
+/**
+ * Default service directory name for main service
+ */
+declare const SERVICE_DEFAULT: "default";
+//#endregion
+export { BUILTIN_SCALARS, CHUNK_NAME_RESOLVERS, CHUNK_NAME_SCHEMAS, CHUNK_PATH_GRAPHQL, CHUNK_PATH_UNKNOWN, CODEGEN_EXTERNALS, DEFAULT_CLIENT_TYPES_PATH, DEFAULT_GRAPHQL_SCALARS, DEFAULT_SERVER_TYPES_PATH, DEFINE_DIRECTIVE, DEFINE_FIELD, DEFINE_FUNCTIONS, DEFINE_GRAPHQL_CONFIG, DEFINE_MUTATION, DEFINE_QUERY, DEFINE_RESOLVER, DEFINE_SCHEMA, DEFINE_SUBSCRIPTION, DIRECTIVE_EXTENSIONS, DIRECTIVE_GLOB_PATTERN, DIR_APP_GRAPHQL, DIR_BUILD_NITRO, DIR_BUILD_NUXT, DIR_CLIENT_GRAPHQL, DIR_EXTERNAL, DIR_ROUTES_GRAPHQL, DIR_SERVER_GRAPHQL, DIR_SERVER_GRAPHQL_WIN, DefineFunction, ENDPOINT_DEBUG, ENDPOINT_GRAPHQL, ENDPOINT_HEALTH, FEDERATION_EXTERNALS, FILE_CLIENT_TYPES, FILE_CONFIG_TS, FILE_CONTEXT_DTS, FILE_CONTEXT_TS, FILE_DIRECTIVES_GRAPHQL, FILE_GRAPHQL_CONFIG, FILE_GRAPHQL_DTS, FILE_INDEX_TS, FILE_OFETCH_TS, FILE_SCHEMA_GRAPHQL, FILE_SCHEMA_TS, FILE_SDK_TS, FILE_SERVER_TYPES, FRAMEWORK_NITRO, FRAMEWORK_NUXT, FRAMEWORK_STANDALONE, Framework, GLOB_SCAN_PATTERN, GRAPHQL_EXTENSIONS, GRAPHQL_FRAMEWORK_APOLLO, GRAPHQL_FRAMEWORK_YOGA, GRAPHQL_GLOB_PATTERN, GRAPHQL_HTTP_METHODS, GraphQLFramework, HTTP_STATUS_BAD_REQUEST, HTTP_STATUS_INTERNAL_ERROR, LOG_TAG, PATTERN_CLIENT_EXTERNAL_TYPES, PLACEHOLDER_BUILD_DIR, PLACEHOLDER_CLIENT_GRAPHQL, PLACEHOLDER_FRAMEWORK, PLACEHOLDER_ROOT_DIR, PLACEHOLDER_SERVER_GRAPHQL, PLACEHOLDER_SERVICE_NAME, PLACEHOLDER_TYPES_DIR, RESOLVER_EXTENSIONS, RESOLVER_GLOB_PATTERN, RESOLVER_TYPE_DIRECTIVE, RESOLVER_TYPE_MUTATION, RESOLVER_TYPE_QUERY, RESOLVER_TYPE_RESOLVER, RESOLVER_TYPE_SUBSCRIPTION, RESOLVER_TYPE_TYPE, ResolverType, SERVICE_DEFAULT };