nitro-graphql 2.0.0-beta.21 → 2.0.0-beta.22

package/README.md

@@ -649,7 +649,7 @@ server/
 - ✅ Verify exports are named exports
 
 **Import errors**
-- ✅ Use correct path: `nitro-graphql/utils/define`
+- ✅ Use correct path: `nitro-graphql/define`
 - ✅ Use named exports in resolvers
 
 **Vite: "Parse failure: Expected ';', '}' or <eof>" on GraphQL files**

package/dist/define.d.mts

@@ -0,0 +1,294 @@
+import { StandardSchemaV1 } from "./types/standard-schema.mjs";
+import "./types/index.mjs";
+import { DefineDirectiveConfig, DefineServerConfig, DirectiveDefinition, Flatten } from "./types/define.mjs";
+import { NPMConfig, Resolvers, ResolversTypes } from "#graphql/server";
+
+//#region src/define.d.ts
+
+/**
+ * Define schema extensions programmatically for GraphQL types.
+ *
+ * This function allows you to provide runtime schema definitions that extend
+ * your GraphQL types with additional validation or transformation logic using
+ * StandardSchemaV1 compliant validators (e.g., Valibot, Zod, ArkType).
+ *
+ * @template T - A partial record mapping GraphQL type names to their schema definitions
+ * @param config - An object mapping GraphQL type names to StandardSchemaV1 schema instances
+ * @returns The flattened schema configuration with proper type inference
+ *
+ * @example
+ * ```typescript
+ * import * as v from 'valibot'
+ *
+ * export const schemas = defineSchema({
+ *   CreateUserInput: v.object({
+ *     email: v.pipe(v.string(), v.email()),
+ *     age: v.pipe(v.number(), v.minValue(18))
+ *   })
+ * })
+ * ```
+ */
+declare function defineSchema<T extends Partial<Record<keyof ResolversTypes, StandardSchemaV1>>>(config: T): Flatten<T>;
+/**
+ * Define a complete GraphQL resolver object with full type safety.
+ *
+ * Use this function when you need to define multiple resolver types (Query, Mutation,
+ * Subscription, and custom types) in a single resolver file. This provides type inference
+ * and auto-completion for all resolver fields.
+ *
+ * @param resolvers - A complete resolver object containing Query, Mutation, Subscription, or custom type resolvers
+ * @returns The same resolver object with preserved type information
+ *
+ * @example
+ * ```typescript
+ * export const userResolvers = defineResolver({
+ *   Query: {
+ *     user: async (_, { id }, context) => {
+ *       return await context.storage.getItem(`user:${id}`)
+ *     }
+ *   },
+ *   Mutation: {
+ *     createUser: async (_, { input }, context) => {
+ *       const user = { id: generateId(), ...input }
+ *       await context.storage.setItem(`user:${user.id}`, user)
+ *       return user
+ *     }
+ *   },
+ *   User: {
+ *     fullName: (parent) => `${parent.firstName} ${parent.lastName}`
+ *   }
+ * })
+ * ```
+ */
+declare function defineResolver(resolvers: Resolvers): Resolvers;
+/**
+ * Define GraphQL Query resolvers with full type safety.
+ *
+ * Use this helper when you only need to define Query resolvers. It automatically
+ * wraps your resolvers in the correct structure and provides type inference for
+ * all query fields defined in your GraphQL schema.
+ *
+ * @param resolvers - An object containing Query field resolvers (defaults to empty object)
+ * @returns A Resolvers object with the Query field populated
+ *
+ * @example
+ * ```typescript
+ * export const userQueries = defineQuery({
+ *   user: async (_, { id }, context) => {
+ *     return await fetchUser(id)
+ *   },
+ *   users: async (_, __, context) => {
+ *     return await fetchAllUsers()
+ *   }
+ * })
+ * ```
+ *
+ * @remarks
+ * Named exports are required. Do not use default exports with this function.
+ */
+declare function defineQuery(resolvers?: Resolvers['Query']): Resolvers;
+/**
+ * Define GraphQL Mutation resolvers with full type safety.
+ *
+ * Use this helper when you only need to define Mutation resolvers. It automatically
+ * wraps your resolvers in the correct structure and provides type inference for
+ * all mutation fields defined in your GraphQL schema.
+ *
+ * @param resolvers - An object containing Mutation field resolvers (defaults to empty object)
+ * @returns A Resolvers object with the Mutation field populated
+ *
+ * @example
+ * ```typescript
+ * export const userMutations = defineMutation({
+ *   createUser: async (_, { input }, context) => {
+ *     const user = await context.db.users.create(input)
+ *     return user
+ *   },
+ *   updateUser: async (_, { id, input }, context) => {
+ *     return await context.db.users.update(id, input)
+ *   },
+ *   deleteUser: async (_, { id }, context) => {
+ *     return await context.db.users.delete(id)
+ *   }
+ * })
+ * ```
+ *
+ * @remarks
+ * Named exports are required. Do not use default exports with this function.
+ */
+declare function defineMutation(resolvers?: Resolvers['Mutation']): Resolvers;
+/**
+ * Define GraphQL Subscription resolvers with full type safety.
+ *
+ * Use this helper when you need to define real-time Subscription resolvers. It automatically
+ * wraps your resolvers in the correct structure and provides type inference for
+ * all subscription fields defined in your GraphQL schema.
+ *
+ * @param resolvers - An object containing Subscription field resolvers (defaults to empty object)
+ * @returns A Resolvers object with the Subscription field populated
+ *
+ * @example
+ * ```typescript
+ * import { Repeater } from '@repeaterjs/repeater'
+ *
+ * export const messageSubscriptions = defineSubscription({
+ *   messageAdded: {
+ *     subscribe: async function* (_, { channelId }, context) {
+ *       const pubsub = context.pubsub
+ *       yield* pubsub.subscribe(`channel:${channelId}`)
+ *     }
+ *   },
+ *   userStatusChanged: {
+ *     subscribe: async (_, __, context) => {
+ *       return new Repeater(async (push, stop) => {
+ *         // Real-time subscription logic
+ *       })
+ *     }
+ *   }
+ * })
+ * ```
+ *
+ * @remarks
+ * Named exports are required. Subscriptions require async iterators or generators.
+ */
+declare function defineSubscription(resolvers?: Resolvers['Subscription']): Resolvers;
+/**
+ * Define custom GraphQL type resolvers with full type safety.
+ *
+ * Use this function to define field resolvers for custom GraphQL types (non-scalar types).
+ * This is useful for computed fields, field-level transformations, or resolving relationships
+ * between types. The function provides type inference for all custom types in your schema.
+ *
+ * @param resolvers - An object containing custom type field resolvers
+ * @returns The same resolver object with preserved type information
+ *
+ * @example
+ * ```typescript
+ * // For a User type with computed fields
+ * export const userTypeResolvers = defineType({
+ *   User: {
+ *     fullName: (parent) => `${parent.firstName} ${parent.lastName}`,
+ *     age: (parent) => {
+ *       const today = new Date()
+ *       return today.getFullYear() - parent.birthYear
+ *     },
+ *     posts: async (parent, _, context) => {
+ *       return await context.db.posts.findByUserId(parent.id)
+ *     }
+ *   }
+ * })
+ * ```
+ *
+ * @remarks
+ * This is functionally equivalent to defineResolver but semantically indicates
+ * you're defining type-specific field resolvers rather than root-level operations.
+ */
+declare function defineType(resolvers: Resolvers): Resolvers;
+/**
+ * Define GraphQL server configuration with full type safety.
+ *
+ * Use this function to configure your GraphQL server settings including schema,
+ * context, plugins, and framework-specific options. Supports both GraphQL Yoga
+ * and Apollo Server configurations with proper type inference.
+ *
+ * @template T - The NPMConfig type (GraphQL Yoga or Apollo Server config)
+ * @param config - Partial server configuration object
+ * @returns The same configuration object with preserved type information
+ *
+ * @example
+ * ```typescript
+ * // GraphQL Yoga configuration
+ * export default defineGraphQLConfig({
+ *   schema: {
+ *     // Schema directives, custom scalars, etc.
+ *   },
+ *   context: async (event) => {
+ *     return {
+ *       user: await getUserFromEvent(event),
+ *       db: getDatabase()
+ *     }
+ *   },
+ *   yoga: {
+ *     graphiql: true,
+ *     maskedErrors: false
+ *   }
+ * })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Apollo Server configuration
+ * export default defineGraphQLConfig({
+ *   apollo: {
+ *     introspection: true,
+ *     csrfPrevention: true,
+ *     plugins: [ApolloServerPluginLandingPageGraphQLPlayground()]
+ *   }
+ * })
+ * ```
+ */
+declare function defineGraphQLConfig<T extends NPMConfig = NPMConfig>(config: Partial<DefineServerConfig<T>>): Partial<DefineServerConfig<T>>;
+/**
+ * Define a custom GraphQL directive with full type safety.
+ *
+ * This function creates a GraphQL directive definition that can be used to add
+ * custom behavior to your GraphQL schema. It automatically generates the directive's
+ * schema definition string and provides runtime transformation capabilities.
+ *
+ * @param config - The directive configuration object
+ * @param config.name - The name of the directive (without the @ symbol)
+ * @param config.locations - Array of GraphQL directive locations where this directive can be applied
+ * @param config.args - Optional arguments the directive accepts with their types and default values
+ * @param config.transformer - Optional function to transform the schema when this directive is applied
+ * @returns A DirectiveDefinition object with the schema definition and runtime behavior
+ *
+ * @example
+ * ```typescript
+ * import { mapSchema, getDirective, MapperKind } from '@graphql-tools/utils'
+ *
+ * export const upperDirective = defineDirective({
+ *   name: 'upper',
+ *   locations: ['FIELD_DEFINITION'],
+ *   transformer: (schema) => {
+ *     return mapSchema(schema, {
+ *       [MapperKind.OBJECT_FIELD]: (fieldConfig) => {
+ *         const directive = getDirective(schema, fieldConfig, 'upper')?.[0]
+ *         if (directive) {
+ *           const { resolve = defaultFieldResolver } = fieldConfig
+ *           fieldConfig.resolve = async (source, args, context, info) => {
+ *             const result = await resolve(source, args, context, info)
+ *             return typeof result === 'string' ? result.toUpperCase() : result
+ *           }
+ *         }
+ *         return fieldConfig
+ *       }
+ *     })
+ *   }
+ * })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Directive with arguments
+ * export const authDirective = defineDirective({
+ *   name: 'auth',
+ *   locations: ['FIELD_DEFINITION', 'OBJECT'],
+ *   args: {
+ *     requires: {
+ *       type: 'Role!',
+ *       defaultValue: 'USER'
+ *     }
+ *   },
+ *   transformer: (schema) => {
+ *     // Implementation for auth checking
+ *   }
+ * })
+ * ```
+ *
+ * @remarks
+ * The generated directive schema definition is stored as a non-enumerable `__schema`
+ * property on the returned object and is automatically included in your GraphQL schema.
+ */
+declare function defineDirective(config: DefineDirectiveConfig): DirectiveDefinition;
+//#endregion
+export { defineDirective, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

package/dist/define.mjs

@@ -0,0 +1,321 @@
+//#region src/define.ts
+/**
+* Define schema extensions programmatically for GraphQL types.
+*
+* This function allows you to provide runtime schema definitions that extend
+* your GraphQL types with additional validation or transformation logic using
+* StandardSchemaV1 compliant validators (e.g., Valibot, Zod, ArkType).
+*
+* @template T - A partial record mapping GraphQL type names to their schema definitions
+* @param config - An object mapping GraphQL type names to StandardSchemaV1 schema instances
+* @returns The flattened schema configuration with proper type inference
+*
+* @example
+* ```typescript
+* import * as v from 'valibot'
+*
+* export const schemas = defineSchema({
+*   CreateUserInput: v.object({
+*     email: v.pipe(v.string(), v.email()),
+*     age: v.pipe(v.number(), v.minValue(18))
+*   })
+* })
+* ```
+*/
+function defineSchema(config) {
+	return config;
+}
+/**
+* Define a complete GraphQL resolver object with full type safety.
+*
+* Use this function when you need to define multiple resolver types (Query, Mutation,
+* Subscription, and custom types) in a single resolver file. This provides type inference
+* and auto-completion for all resolver fields.
+*
+* @param resolvers - A complete resolver object containing Query, Mutation, Subscription, or custom type resolvers
+* @returns The same resolver object with preserved type information
+*
+* @example
+* ```typescript
+* export const userResolvers = defineResolver({
+*   Query: {
+*     user: async (_, { id }, context) => {
+*       return await context.storage.getItem(`user:${id}`)
+*     }
+*   },
+*   Mutation: {
+*     createUser: async (_, { input }, context) => {
+*       const user = { id: generateId(), ...input }
+*       await context.storage.setItem(`user:${user.id}`, user)
+*       return user
+*     }
+*   },
+*   User: {
+*     fullName: (parent) => `${parent.firstName} ${parent.lastName}`
+*   }
+* })
+* ```
+*/
+function defineResolver(resolvers) {
+	return resolvers;
+}
+/**
+* Define GraphQL Query resolvers with full type safety.
+*
+* Use this helper when you only need to define Query resolvers. It automatically
+* wraps your resolvers in the correct structure and provides type inference for
+* all query fields defined in your GraphQL schema.
+*
+* @param resolvers - An object containing Query field resolvers (defaults to empty object)
+* @returns A Resolvers object with the Query field populated
+*
+* @example
+* ```typescript
+* export const userQueries = defineQuery({
+*   user: async (_, { id }, context) => {
+*     return await fetchUser(id)
+*   },
+*   users: async (_, __, context) => {
+*     return await fetchAllUsers()
+*   }
+* })
+* ```
+*
+* @remarks
+* Named exports are required. Do not use default exports with this function.
+*/
+function defineQuery(resolvers = {}) {
+	return { Query: { ...resolvers } };
+}
+/**
+* Define GraphQL Mutation resolvers with full type safety.
+*
+* Use this helper when you only need to define Mutation resolvers. It automatically
+* wraps your resolvers in the correct structure and provides type inference for
+* all mutation fields defined in your GraphQL schema.
+*
+* @param resolvers - An object containing Mutation field resolvers (defaults to empty object)
+* @returns A Resolvers object with the Mutation field populated
+*
+* @example
+* ```typescript
+* export const userMutations = defineMutation({
+*   createUser: async (_, { input }, context) => {
+*     const user = await context.db.users.create(input)
+*     return user
+*   },
+*   updateUser: async (_, { id, input }, context) => {
+*     return await context.db.users.update(id, input)
+*   },
+*   deleteUser: async (_, { id }, context) => {
+*     return await context.db.users.delete(id)
+*   }
+* })
+* ```
+*
+* @remarks
+* Named exports are required. Do not use default exports with this function.
+*/
+function defineMutation(resolvers = {}) {
+	return { Mutation: { ...resolvers } };
+}
+/**
+* Define GraphQL Subscription resolvers with full type safety.
+*
+* Use this helper when you need to define real-time Subscription resolvers. It automatically
+* wraps your resolvers in the correct structure and provides type inference for
+* all subscription fields defined in your GraphQL schema.
+*
+* @param resolvers - An object containing Subscription field resolvers (defaults to empty object)
+* @returns A Resolvers object with the Subscription field populated
+*
+* @example
+* ```typescript
+* import { Repeater } from '@repeaterjs/repeater'
+*
+* export const messageSubscriptions = defineSubscription({
+*   messageAdded: {
+*     subscribe: async function* (_, { channelId }, context) {
+*       const pubsub = context.pubsub
+*       yield* pubsub.subscribe(`channel:${channelId}`)
+*     }
+*   },
+*   userStatusChanged: {
+*     subscribe: async (_, __, context) => {
+*       return new Repeater(async (push, stop) => {
+*         // Real-time subscription logic
+*       })
+*     }
+*   }
+* })
+* ```
+*
+* @remarks
+* Named exports are required. Subscriptions require async iterators or generators.
+*/
+function defineSubscription(resolvers = {}) {
+	return { Subscription: { ...resolvers } };
+}
+/**
+* Define custom GraphQL type resolvers with full type safety.
+*
+* Use this function to define field resolvers for custom GraphQL types (non-scalar types).
+* This is useful for computed fields, field-level transformations, or resolving relationships
+* between types. The function provides type inference for all custom types in your schema.
+*
+* @param resolvers - An object containing custom type field resolvers
+* @returns The same resolver object with preserved type information
+*
+* @example
+* ```typescript
+* // For a User type with computed fields
+* export const userTypeResolvers = defineType({
+*   User: {
+*     fullName: (parent) => `${parent.firstName} ${parent.lastName}`,
+*     age: (parent) => {
+*       const today = new Date()
+*       return today.getFullYear() - parent.birthYear
+*     },
+*     posts: async (parent, _, context) => {
+*       return await context.db.posts.findByUserId(parent.id)
+*     }
+*   }
+* })
+* ```
+*
+* @remarks
+* This is functionally equivalent to defineResolver but semantically indicates
+* you're defining type-specific field resolvers rather than root-level operations.
+*/
+function defineType(resolvers) {
+	return resolvers;
+}
+/**
+* Define GraphQL server configuration with full type safety.
+*
+* Use this function to configure your GraphQL server settings including schema,
+* context, plugins, and framework-specific options. Supports both GraphQL Yoga
+* and Apollo Server configurations with proper type inference.
+*
+* @template T - The NPMConfig type (GraphQL Yoga or Apollo Server config)
+* @param config - Partial server configuration object
+* @returns The same configuration object with preserved type information
+*
+* @example
+* ```typescript
+* // GraphQL Yoga configuration
+* export default defineGraphQLConfig({
+*   schema: {
+*     // Schema directives, custom scalars, etc.
+*   },
+*   context: async (event) => {
+*     return {
+*       user: await getUserFromEvent(event),
+*       db: getDatabase()
+*     }
+*   },
+*   yoga: {
+*     graphiql: true,
+*     maskedErrors: false
+*   }
+* })
+* ```
+*
+* @example
+* ```typescript
+* // Apollo Server configuration
+* export default defineGraphQLConfig({
+*   apollo: {
+*     introspection: true,
+*     csrfPrevention: true,
+*     plugins: [ApolloServerPluginLandingPageGraphQLPlayground()]
+*   }
+* })
+* ```
+*/
+function defineGraphQLConfig(config) {
+	return config;
+}
+/**
+* Define a custom GraphQL directive with full type safety.
+*
+* This function creates a GraphQL directive definition that can be used to add
+* custom behavior to your GraphQL schema. It automatically generates the directive's
+* schema definition string and provides runtime transformation capabilities.
+*
+* @param config - The directive configuration object
+* @param config.name - The name of the directive (without the @ symbol)
+* @param config.locations - Array of GraphQL directive locations where this directive can be applied
+* @param config.args - Optional arguments the directive accepts with their types and default values
+* @param config.transformer - Optional function to transform the schema when this directive is applied
+* @returns A DirectiveDefinition object with the schema definition and runtime behavior
+*
+* @example
+* ```typescript
+* import { mapSchema, getDirective, MapperKind } from '@graphql-tools/utils'
+*
+* export const upperDirective = defineDirective({
+*   name: 'upper',
+*   locations: ['FIELD_DEFINITION'],
+*   transformer: (schema) => {
+*     return mapSchema(schema, {
+*       [MapperKind.OBJECT_FIELD]: (fieldConfig) => {
+*         const directive = getDirective(schema, fieldConfig, 'upper')?.[0]
+*         if (directive) {
+*           const { resolve = defaultFieldResolver } = fieldConfig
+*           fieldConfig.resolve = async (source, args, context, info) => {
+*             const result = await resolve(source, args, context, info)
+*             return typeof result === 'string' ? result.toUpperCase() : result
+*           }
+*         }
+*         return fieldConfig
+*       }
+*     })
+*   }
+* })
+* ```
+*
+* @example
+* ```typescript
+* // Directive with arguments
+* export const authDirective = defineDirective({
+*   name: 'auth',
+*   locations: ['FIELD_DEFINITION', 'OBJECT'],
+*   args: {
+*     requires: {
+*       type: 'Role!',
+*       defaultValue: 'USER'
+*     }
+*   },
+*   transformer: (schema) => {
+*     // Implementation for auth checking
+*   }
+* })
+* ```
+*
+* @remarks
+* The generated directive schema definition is stored as a non-enumerable `__schema`
+* property on the returned object and is automatically included in your GraphQL schema.
+*/
+function defineDirective(config) {
+	const args = config.args ? Object.entries(config.args).map(([name, arg]) => {
+		const defaultValue = arg.defaultValue !== void 0 ? ` = ${JSON.stringify(arg.defaultValue)}` : "";
+		return `${name}: ${arg.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 { defineDirective, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

package/dist/routes/apollo-server.d.mts

@@ -1,6 +1,6 @@
-import * as h33 from "h3";
+import * as h31 from "h3";
 
 //#region src/routes/apollo-server.d.ts
-declare const _default: h33.EventHandlerWithFetch<h33.EventHandlerRequest, Promise<any>>;
+declare const _default: h31.EventHandlerWithFetch<h31.EventHandlerRequest, Promise<any>>;
 //#endregion
 export { _default as default };

package/dist/routes/graphql-yoga.d.mts

@@ -1,6 +1,6 @@
-import * as h31 from "h3";
+import * as h33 from "h3";
 
 //#region src/routes/graphql-yoga.d.ts
-declare const _default: h31.EventHandlerWithFetch<h31.EventHandlerRequest, Promise<Response>>;
+declare const _default: h33.EventHandlerWithFetch<h33.EventHandlerRequest, Promise<Response>>;
 //#endregion
 export { _default as default };

package/dist/setup.mjs

@@ -199,7 +199,7 @@ async function setupNitroGraphQL(nitro) {
 	if (nitro.options.imports) {
 		nitro.options.imports.presets ??= [];
 		nitro.options.imports.presets.push({
-			from: fileURLToPath(new URL("utils/define", import.meta.url)),
+			from: fileURLToPath(new URL("define", import.meta.url)),
 			imports: [
 				"defineResolver",
 				"defineMutation",
@@ -346,7 +346,7 @@ export default <IGraphQLConfig> {
 		if (serverConfigPath) writeFileIfNotExists(serverConfigPath, `// Example GraphQL config file please change it to your needs
 // import * as tables from '../drizzle/schema/index'
 // import { useDatabase } from '../utils/useDb'
-import { defineGraphQLConfig } from 'nitro-graphql/utils/define'
+import { defineGraphQLConfig } from 'nitro-graphql/define'
 
 export default defineGraphQLConfig({
 // graphql-yoga example config

package/dist/{utils → types}/define.d.mts

@@ -1,37 +1,14 @@
-import { StandardSchemaV1 } from "../types/standard-schema.mjs";
-import "../types/index.mjs";
 import { GraphQLSchema } from "graphql";
 import { ApolloServerOptions } from "@apollo/server";
 import { H3Event } from "h3";
 import { YogaServerOptions } from "graphql-yoga";
-import { NPMConfig, Resolvers, ResolversTypes } from "#graphql/server";
+import { NPMConfig } from "#graphql/server";
 
-//#region src/utils/define.d.ts
+//#region src/types/define.d.ts
 type Flatten<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;
-declare function defineSchema<T extends Partial<Record<keyof ResolversTypes, StandardSchemaV1>>>(config: T): Flatten<T>;
-declare function defineResolver(resolvers: Resolvers): Resolvers;
-type ResolverQuery = Resolvers extends {
-  Query: infer Q;
-} ? Q : never;
-declare function defineQuery(resolvers?: Resolvers['Query']): Resolvers;
-declare function defineMutation(resolvers?: Resolvers['Mutation']): Resolvers;
-declare function defineSubscription(resolvers?: Resolvers['Subscription']): Resolvers;
-declare function defineType(resolvers: Resolvers): Resolvers;
 type DefineServerConfig<T extends NPMConfig = NPMConfig> = T['framework'] extends 'graphql-yoga' ? Partial<YogaServerOptions<H3Event, Partial<H3Event>>> : T['framework'] extends 'apollo-server' ? Partial<ApolloServerOptions<H3Event>> : Partial<YogaServerOptions<H3Event, Partial<H3Event>>> | Partial<ApolloServerOptions<H3Event>>;
-declare function defineGraphQLConfig<T extends NPMConfig = NPMConfig>(config: Partial<DefineServerConfig<T>>): Partial<DefineServerConfig<T>>;
 type DirectiveLocationName = 'QUERY' | 'MUTATION' | 'SUBSCRIPTION' | 'FIELD' | 'FRAGMENT_DEFINITION' | 'FRAGMENT_SPREAD' | 'INLINE_FRAGMENT' | 'VARIABLE_DEFINITION' | 'SCHEMA' | 'SCALAR' | 'OBJECT' | 'FIELD_DEFINITION' | 'ARGUMENT_DEFINITION' | 'INTERFACE' | 'UNION' | 'ENUM' | 'ENUM_VALUE' | 'INPUT_OBJECT' | 'INPUT_FIELD_DEFINITION';
-type GraphQLScalarType = 'String' | 'Int' | 'Float' | 'Boolean' | 'ID' | 'JSON' | 'DateTime';
-type GraphQLBaseType = GraphQLScalarType | (string & {});
 type GraphQLArgumentType = 'String' | 'Int' | 'Float' | 'Boolean' | 'ID' | 'JSON' | 'DateTime' | 'String!' | 'Int!' | 'Float!' | 'Boolean!' | 'ID!' | 'JSON!' | 'DateTime!' | '[String]' | '[String!]' | '[String]!' | '[String!]!' | '[Int]' | '[Int!]' | '[Int]!' | '[Int!]!' | '[Float]' | '[Float!]' | '[Float]!' | '[Float!]!' | '[Boolean]' | '[Boolean!]' | '[Boolean]!' | '[Boolean!]!' | '[ID]' | '[ID!]' | '[ID]!' | '[ID!]!' | '[JSON]' | '[JSON!]' | '[JSON]!' | '[JSON!]!' | '[DateTime]' | '[DateTime!]' | '[DateTime]!' | '[DateTime!]!' | (string & {});
-interface DirectiveArgument<T extends GraphQLArgumentType = GraphQLArgumentType> {
-  /**
-   * GraphQL type for the argument
-   * @example 'String', 'Int!', '[String!]!', 'DateTime', 'JSON'
-   */
-  type: T;
-  defaultValue?: any;
-  description?: string;
-}
 interface DirectiveArg {
   type: GraphQLArgumentType;
   defaultValue?: any;
@@ -57,17 +34,5 @@ interface DefineDirectiveConfig {
   isRepeatable?: boolean;
   transformer?: (schema: GraphQLSchema) => GraphQLSchema;
 }
-/**
- * Helper function to create directive arguments with proper type inference
- * @example
- * args: {
- *   myArg: arg('String!', { defaultValue: 'hello' })
- * }
- */
-declare function arg<T extends GraphQLArgumentType>(type: T, options?: {
-  defaultValue?: any;
-  description?: string;
-}): DirectiveArgument<T>;
-declare function defineDirective(config: DefineDirectiveConfig): DirectiveDefinition;
 //#endregion
-export { DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, ResolverQuery, arg, defineDirective, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };
+export { DefineDirectiveConfig, DefineServerConfig, DirectiveDefinition, Flatten };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nitro-graphql",
   "type": "module",
-  "version": "2.0.0-beta.21",
+  "version": "2.0.0-beta.22",
   "description": "GraphQL integration for Nitro",
   "license": "MIT",
   "sideEffects": false,
@@ -44,9 +44,9 @@
       "types": "./dist/utils/index.d.mts",
       "import": "./dist/utils/index.mjs"
     },
-    "./utils/define": {
-      "types": "./dist/utils/define.d.mts",
-      "import": "./dist/utils/define.mjs"
+    "./define": {
+      "types": "./dist/define.d.mts",
+      "import": "./dist/define.mjs"
     },
     "./utils/apollo": {
       "types": "./dist/utils/apollo.d.mts",
@@ -116,17 +116,18 @@
     "@nuxt/kit": "^4.2.1",
     "@nuxt/schema": "^4.2.1",
     "@types/node": "^24.10.0",
+    "@vitejs/devtools": "^0.0.0-alpha.16",
     "bumpp": "^10.3.1",
     "changelogen": "^0.6.2",
     "crossws": "0.3.5",
     "eslint": "^9.39.1",
-    "graphql": "16.11.0",
-    "graphql-yoga": "^5.16.2",
+    "graphql": "^16.12.0",
+    "graphql-yoga": "^5.16.0",
     "h3": "^2.0.1-rc.5",
     "nitro": "npm:nitro-nightly@latest",
     "tsdown": "^0.16.1",
     "typescript": "^5.9.3",
-    "vite": "^7.2.2",
+    "vite": "npm:rolldown-vite@latest",
     "vitepress-plugin-llms": "^1.9.1"
   },
   "resolutions": {

package/dist/utils/define.mjs

@@ -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/vite.d.mts

@@ -1,30 +0,0 @@
-import { NitroGraphQLOptions } from "./types/index.mjs";
-import { NitroModule } from "nitro/types";
-import { Plugin } from "vite";
-
-//#region src/vite.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
- * ```ts
- * import { defineConfig } from 'vite'
- * import { nitro } from 'nitro/vite'
- * import { graphql } from 'nitro-graphql/vite'
- *
- * export default defineConfig({
- *   plugins: [
- *     graphql({ framework: 'graphql-yoga' }), // Auto-registers Nitro module
- *     nitro()
- *   ]
- * })
- * ```
- */
-declare function graphql(options?: NitroGraphQLOptions): Plugin & {
-  nitro?: NitroModule;
-};
-//#endregion
-export { graphql };

package/dist/vite.mjs

@@ -1,49 +0,0 @@
-import { setupNitroGraphQL } from "./setup.mjs";
-import { readFile } from "node:fs/promises";
-import defu from "defu";
-
-//#region src/vite.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
-* ```ts
-* import { defineConfig } from 'vite'
-* import { nitro } from 'nitro/vite'
-* import { graphql } from 'nitro-graphql/vite'
-*
-* export default defineConfig({
-*   plugins: [
-*     graphql({ framework: 'graphql-yoga' }), // Auto-registers Nitro module
-*     nitro()
-*   ]
-* })
-* ```
-*/
-function graphql(options) {
-	return {
-		name: "nitro-graphql:vite",
-		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);
-		} }
-	};
-}
-
-//#endregion
-export { graphql };