nitro-graphql 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/types/index.d.ts

@@ -1,128 +0,0 @@
-import { StandardSchemaV1 } from "./standard-schema.js";
-import { ESMCodeGenOptions } from "knitwork";
-import { IResolvers } from "@graphql-tools/utils";
-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 { TypeScriptResolversPluginConfig } from "@graphql-codegen/typescript-resolvers";
-
-//#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;
-  }
-}
-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;
-  };
-}
-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;
-}
-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[];
-}
-//#endregion
-export { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, FederationConfig, GenImport, GenericSdkConfig, NitroGraphQLOptions };

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

@@ -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/apollo.js

@@ -1,61 +0,0 @@
-import { HeaderMap } from "@apollo/server";
-import { eventHandler, getHeaders, isMethod, readBody, setHeaders } from "h3";
-
-//#region src/utils/apollo.ts
-function startServerAndCreateH3Handler(server, options) {
-	const defaultContext = () => Promise.resolve({});
-	const contextFunction = options?.context ?? defaultContext;
-	return eventHandler({
-		handler: async (event) => {
-			const apolloServer = typeof server === "function" ? server() : server;
-			if (!options?.serverAlreadyStarted) apolloServer.startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests();
-			if (isMethod(event, "OPTIONS")) return null;
-			try {
-				const graphqlRequest = await toGraphqlRequest(event);
-				const { body, headers, status } = await apolloServer.executeHTTPGraphQLRequest({
-					httpGraphQLRequest: graphqlRequest,
-					context: () => contextFunction({ event })
-				});
-				if (body.kind === "chunked") throw new Error("Incremental delivery not implemented");
-				setHeaders(event, Object.fromEntries(headers));
-				event.res.statusCode = status || 200;
-				return body.string;
-			} catch (error) {
-				if (error instanceof SyntaxError) {
-					event.res.statusCode = 400;
-					return error.message;
-				} else throw error;
-			}
-		},
-		websocket: options?.websocket
-	});
-}
-async function toGraphqlRequest(event) {
-	return {
-		method: event.req.method || "POST",
-		headers: normalizeHeaders(getHeaders(event)),
-		search: normalizeQueryString(event.req.url),
-		body: await normalizeBody(event)
-	};
-}
-function normalizeHeaders(headers) {
-	const headerMap = new HeaderMap();
-	for (const [key, value] of Object.entries(headers)) if (Array.isArray(value)) headerMap.set(key, value.join(","));
-	else if (value) headerMap.set(key, value);
-	return headerMap;
-}
-function normalizeQueryString(url) {
-	if (!url) return "";
-	return url.split("?")[1] || "";
-}
-async function normalizeBody(event) {
-	if (isMethod(event, [
-		"PATCH",
-		"POST",
-		"PUT",
-		"DELETE"
-	])) return await readBody(event);
-}
-
-//#endregion
-export { startServerAndCreateH3Handler };

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

@@ -1,38 +0,0 @@
-import { CodegenClientConfig, ExternalGraphQLService, GenericSdkConfig } from "../types/index.js";
-import { GraphQLSchema } from "graphql";
-import { Source } from "@graphql-tools/utils";
-import { LoadSchemaOptions, UnnormalizedTypeDefPointer } from "@graphql-tools/load";
-
-//#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): Promise<false | {
-  types: string;
-  sdk: string;
-}>;
-/**
- * Generate client types for external GraphQL service
- */
-declare function generateExternalClientTypes(service: ExternalGraphQLService, schema: GraphQLSchema, docs: Source[]): Promise<{
-  types: string;
-  sdk: string;
-} | false>;
-//#endregion
-export { GraphQLLoadSchemaOptions, GraphQLTypeDefPointer, downloadAndSaveSchema, generateClientTypes, generateExternalClientTypes, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments };

package/dist/utils/client-codegen.js

@@ -1,290 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { consola as consola$1 } from "consola";
-import { defu as defu$1 } from "defu";
-import { dirname, resolve } from "pathe";
-import { parse } from "graphql";
-import { printSchemaWithDirectives } from "@graphql-tools/utils";
-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 { CurrencyResolver, DateTimeISOResolver, DateTimeResolver, JSONObjectResolver, JSONResolver, NonEmptyStringResolver, UUIDResolver } from "graphql-scalars";
-
-//#region src/utils/client-codegen.ts
-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: ""
-	};
-}
-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) {
-	if (docs.length === 0 && !serviceName) {
-		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: {
-			DateTime: DateTimeResolver.extensions.codegenScalarType,
-			DateTimeISO: DateTimeISOResolver.extensions.codegenScalarType,
-			UUID: UUIDResolver.extensions.codegenScalarType,
-			JSON: JSONResolver.extensions.codegenScalarType,
-			JSONObject: JSONObjectResolver.extensions.codegenScalarType,
-			NonEmptyString: NonEmptyStringResolver.extensions.codegenScalarType,
-			Currency: CurrencyResolver.extensions.codegenScalarType,
-			File: {
-				input: "File",
-				output: "File"
-			}
-		}
-	}, 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 = 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) {
-	return generateClientTypes(schema, docs, service.codegen?.client || {}, service.codegen?.clientSDK || {}, void 0, service.name);
-}
-
-//#endregion
-export { downloadAndSaveSchema, generateClientTypes, generateExternalClientTypes, graphQLLoadSchemaSync, loadExternalSchema, loadGraphQLDocuments };

package/dist/utils/define.js

@@ -1,57 +0,0 @@
-//#region src/utils/define.ts
-function defineSchema(config) {
-	return config;
-}
-function defineResolver(resolvers) {
-	return resolvers;
-}
-function defineQuery(resolvers = {}) {
-	return { Query: { ...resolvers } };
-}
-function defineMutation(resolvers = {}) {
-	return { Mutation: { ...resolvers } };
-}
-function defineSubscription(resolvers = {}) {
-	return { Subscription: { ...resolvers } };
-}
-function defineType(resolvers) {
-	return resolvers;
-}
-function defineGraphQLConfig(config) {
-	return config;
-}
-/**
-* Helper function to create directive arguments with proper type inference
-* @example
-* args: {
-*   myArg: arg('String!', { defaultValue: 'hello' })
-* }
-*/
-function arg(type, options) {
-	return {
-		type,
-		...options
-	};
-}
-function defineDirective(config) {
-	const args = config.args ? Object.entries(config.args).map(([name, arg$1]) => {
-		const defaultValue = arg$1.defaultValue !== void 0 ? ` = ${JSON.stringify(arg$1.defaultValue)}` : "";
-		return `${name}: ${arg$1.type}${defaultValue}`;
-	}).join(", ") : "";
-	const argsString = args ? `(${args})` : "";
-	const locations = config.locations.join(" | ");
-	const schemaDefinition = `directive @${config.name}${argsString} on ${locations}`;
-	Object.defineProperty(config, "__schema", {
-		value: schemaDefinition,
-		enumerable: false,
-		configurable: false,
-		writable: false
-	});
-	return {
-		...config,
-		locations: [...config.locations]
-	};
-}
-
-//#endregion
-export { arg, defineDirective, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

package/dist/utils/index.d.ts

@@ -1,39 +0,0 @@
-import { GenImport } from "../types/index.js";
-import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.js";
-import { Nitro } from "nitro/types";
-
-//#region src/utils/index.d.ts
-declare const GLOB_SCAN_PATTERN = "**/*.{graphql,gql,js,mjs,cjs,ts,mts,cts,tsx,jsx}";
-/**
- * Get all Nuxt layer directories from Nitro config
- */
-declare function getLayerDirectories(nitro: Nitro): string[];
-/**
- * Get all Nuxt layer server directories from Nitro config
- */
-declare function getLayerServerDirectories(nitro: Nitro): string[];
-/**
- * Get all Nuxt layer app directories from Nitro config
- */
-declare function getLayerAppDirectories(nitro: Nitro): string[];
-/**
- * Generate layer-aware ignore patterns for auto-generated files
- */
-declare function generateLayerIgnorePatterns(): string[];
-declare function getImportId(p: string, lazy?: boolean): string;
-declare function relativeWithDot(from: string, to: string): string;
-declare function scanGraphql(nitro: Nitro): Promise<string[]>;
-declare function scanResolvers(nitro: Nitro): Promise<GenImport[]>;
-declare function scanDirectives(nitro: Nitro): Promise<GenImport[]>;
-declare function scanSchemas(nitro: Nitro): Promise<string[]>;
-declare function scanDocs(nitro: Nitro): Promise<string[]>;
-/**
- * Scan documents for a specific external service
- */
-declare function scanExternalServiceDocs(nitro: Nitro, serviceName: string, patterns: string[]): Promise<string[]>;
-/**
- * Validate external GraphQL service configuration
- */
-declare function validateExternalServices(services: unknown[]): string[];
-//#endregion
-export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, validateExternalServices };