nitro-graphql 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Silgi.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,476 @@
+# Nitro GraphQL Yoga Module
+
+> [!NOTE]
+> This project is actively under development. We're always open to new ideas, different perspectives, and feature suggestions! If you have a suggestion, please first [open an issue](https://github.com/productdevbook/nitro-graphql/issues) to discuss it, then you can contribute with a PR.
+
+A standalone Nitro module that integrates GraphQL Yoga server into any Nitro application with automatic type generation and file watching.
+
+## Features
+
+- 🚀 Easy GraphQL server setup with GraphQL Yoga
+- 🔧 Auto-discovery of GraphQL schema and resolver files
+- 📝 Automatic TypeScript type generation from GraphQL schemas
+- 🎮 Apollo Sandbox integration (instead of GraphiQL)
+- 🏥 Built-in health check endpoint
+- 💾 Configurable cache headers for better performance
+- 🔌 Works with any Nitro-based application
+- 🎯 Zero-config with sensible defaults
+- 📂 File-based resolver organization
+- 🔄 Hot reload in development mode
+- 📦 Optimized bundle size with dynamic imports
+- 🏷️ Minimal logging with consistent tagging
+
+## Installation
+
+```bash
+npm install nitro-graphql
+# or
+pnpm add nitro-graphql
+# or
+yarn add nitro-graphql
+```
+
+## Usage
+
+### 1. Add the module to your Nitro config
+
+```ts
+// nitro.config.ts
+import { defineNitroConfig } from 'nitropack/config'
+
+export default defineNitroConfig({
+  modules: ['nitro-graphql'],
+
+  // Optional configuration
+  graphqlYoga: {
+    endpoint: '/api/graphql', // default
+    playground: true, // default (Apollo Sandbox)
+    cors: false, // default
+    cacheHeaders: {
+      enabled: true, // default
+      maxAge: 604800, // default (1 week)
+    },
+    client: {
+      enabled: false, // default
+      outputPath: undefined, // Will default to .nitro/types/graphql-client.generated.ts
+      watchPatterns: undefined, // Will default to src/**/*.{graphql,gql} excluding server/graphql
+      config: {
+        documentMode: 'string',
+        emitLegacyCommonJSImports: false,
+        useTypeImports: true,
+        enumsAsTypes: true,
+      }
+    }
+  }
+})
+```
+
+### 2. Create your GraphQL schema files
+
+The module automatically scans for GraphQL files in your `graphql/` directory using a domain-driven structure:
+
+#### Main Schema File
+```graphql
+# server/graphql/schema.graphql
+scalar DateTime
+scalar JSON
+
+type Query {
+  hello: String!
+  greeting(name: String!): String!
+}
+
+type Mutation
+```
+
+#### Domain-specific Schema Files
+```graphql
+# server/graphql/users/user.graphql
+type User {
+  id: ID!
+  name: String!
+  email: String!
+  createdAt: DateTime!
+}
+
+input CreateUserInput {
+  name: String!
+  email: String!
+}
+
+extend type Query {
+  users: [User!]!
+  user(id: ID!): User
+}
+
+extend type Mutation {
+  createUser(input: CreateUserInput!): User!
+}
+```
+
+#### Domain-based Resolver Files
+```ts
+// server/graphql/users/user-queries.ts
+import { createResolver } from 'nitro-graphql'
+
+export default createResolver({
+  Query: {
+    users: async (_, __, { storage }) => {
+      return await storage.getItem('users') || []
+    },
+    user: async (_, { id }, { storage }) => {
+      const users = await storage.getItem('users') || []
+      return users.find(user => user.id === id)
+    }
+  }
+})
+```
+
+```ts
+// server/graphql/users/create-user.ts
+import { createResolver } from 'nitro-graphql'
+
+export default createResolver({
+  Mutation: {
+    createUser: async (_, { input }, { storage }) => {
+      const users = await storage.getItem('users') || []
+      const user = {
+        id: Date.now().toString(),
+        ...input,
+        createdAt: new Date()
+      }
+      users.push(user)
+      await storage.setItem('users', users)
+      return user
+    }
+  }
+})
+```
+
+### 3. Using the utilities
+
+The module provides utilities for better developer experience:
+
+```ts
+// server/graphql/hello.ts
+import { createResolver } from 'nitro-graphql'
+
+export default createResolver({
+  Query: {
+    hello: () => 'Hello World!',
+    greeting: (_, { name }) => `Hello ${name}!`
+  }
+})
+```
+
+### 4. Type Generation
+
+The module automatically generates TypeScript types from your GraphQL schema:
+
+- **Server types**: `.nitro/types/graphql-types.generated.ts`
+- **Type declarations**: `.nitro/types/graphql.d.ts`
+
+These types are automatically available in your resolvers:
+
+```ts
+import type { QueryResolvers } from '#build/graphql-types.generated'
+// server/graphql/users/user-queries.ts
+import { createResolver } from 'nitro-graphql'
+
+export default createResolver({
+  Query: {
+    users: async (_, __, { storage }): Promise<User[]> => {
+      return await storage.getItem('users') || []
+    }
+  } satisfies QueryResolvers
+})
+```
+
+## File Structure
+
+The module follows a domain-driven file structure:
+
+```
+server/
+├── graphql/
+│   ├── schema.graphql           # Main schema file with scalars and base types
+│   ├── hello.ts                 # Global resolvers
+│   ├── users/
+│   │   ├── user.graphql         # User schema definitions
+│   │   ├── user-queries.ts      # User query resolvers
+│   │   └── create-user.ts       # User mutation resolvers
+│   ├── todos/
+│   │   ├── todo.graphql         # Todo schema definitions
+│   │   ├── todo-queries.ts      # Todo query resolvers
+│   │   └── todo-mutations.ts    # Todo mutation resolvers
+│   ├── posts/
+│   │   ├── post.graphql         # Post schema definitions
+│   │   ├── post-queries.ts      # Post query resolvers
+│   │   └── create-post.ts       # Post mutation resolvers
+│   └── comments/
+│       ├── comment.graphql      # Comment schema definitions
+│       ├── comment-queries.ts   # Comment query resolvers
+│       └── add-comment.ts       # Comment mutation resolvers
+```
+
+## Context
+
+The GraphQL context includes:
+- `event`: The H3 event object
+- `request`: The original request object
+- `storage`: Nitro storage instance
+
+```ts
+// Example resolver with full context usage
+import { createResolver } from 'nitro-graphql'
+
+export default createResolver({
+  Query: {
+    currentUser: async (_, __, { event, request, storage }) => {
+      const token = getCookie(event, 'auth-token')
+      const userAgent = getHeader(event, 'user-agent')
+
+      if (!token) {
+        throw new Error('Unauthorized')
+      }
+
+      const userId = await verifyToken(token)
+      return await storage.getItem(`user:${userId}`)
+    }
+  }
+})
+```
+
+## Configuration Options
+
+```ts
+interface NitroGraphQLYogaOptions {
+  // GraphQL endpoint path
+  endpoint?: string // default: '/api/graphql'
+
+  // Enable/disable Apollo Sandbox
+  playground?: boolean // default: true
+
+  // CORS configuration
+  cors?: boolean | {
+    origin?: string | string[] | boolean
+    credentials?: boolean
+    methods?: string[]
+  }
+
+  // Cache headers configuration
+  cacheHeaders?: {
+    enabled?: boolean // default: true
+    maxAge?: number // default: 604800 (1 week)
+  }
+
+  // Client type generation
+  client?: {
+    enabled?: boolean // default: false
+    outputPath?: string // default: buildDir/types/graphql-client.generated.ts
+    watchPatterns?: string[] // default: src/**/*.{graphql,gql} excluding server/graphql
+    config?: {
+      documentMode?: 'string' | 'graphQLTag'
+      emitLegacyCommonJSImports?: boolean
+      useTypeImports?: boolean
+      enumsAsTypes?: boolean
+    }
+  }
+}
+```
+
+## Development Features
+
+### Hot Reload
+The module watches for changes in your GraphQL files and automatically:
+- Regenerates TypeScript types
+- Reloads the GraphQL schema
+- Updates resolvers
+
+### Bundle Optimization
+- Uses dynamic imports to prevent bundling large codegen dependencies
+- Optimized chunk organization for better caching
+- Minimal logging output with consistent `[graphql]` tagging
+
+### Health Check
+Access the health check endpoint at `/api/graphql/health` to verify your GraphQL server status.
+
+## Advanced Usage
+
+### Custom GraphQL Yoga Configuration
+
+You can create a custom GraphQL Yoga configuration file that will be automatically merged with the default configuration. The module will look for this file **only in the `server/graphql/` directory**:
+
+- `server/graphql/yoga.config.ts`
+
+```ts
+import { useCORS } from '@graphql-yoga/plugin-cors'
+import { useResponseCache } from '@graphql-yoga/plugin-response-cache'
+// server/graphql/yoga.config.ts
+import { defineYogaConfig } from 'nitro-graphql'
+
+export default defineYogaConfig({
+  // Add custom plugins
+  plugins: [
+    useCORS({
+      origin: process.env.NODE_ENV === 'production' ? 'https://yourdomain.com' : '*',
+      credentials: true,
+    }),
+    useResponseCache({
+      session: () => null,
+      ttl: 60_000, // 1 minute
+    }),
+  ],
+
+  // Enhanced context with custom properties
+  context: async ({ request }) => {
+    const event = request.$$event
+
+    return {
+      event,
+      request,
+      storage: useStorage(),
+      // Add custom context properties
+      user: await authenticateUser(event),
+      db: await connectDatabase(),
+      startTime: Date.now(),
+    }
+  },
+
+  // Custom error handling
+  maskedErrors: {
+    maskError: (error, message, isDev) => {
+      if (error.message.startsWith('USER_')) {
+        return error // Don't mask user-facing errors
+      }
+      return isDev ? error : new Error('Internal server error')
+    },
+  },
+
+  // Additional yoga options
+  // See: https://the-guild.dev/graphql/yoga-server/docs
+})
+```
+
+**Configuration Merging**: Your custom config is merged with the default config, allowing you to override specific options while keeping defaults for others. The `schema` and `graphqlEndpoint` are always preserved from the module's configuration.
+
+### Client Type Generation
+
+Enable client type generation for your frontend queries:
+
+```ts
+// nitro.config.ts
+export default defineNitroConfig({
+  graphqlYoga: {
+    client: {
+      enabled: true,
+      watchPatterns: [
+        'client/**/*.graphql',
+        'pages/**/*.vue',
+        'components/**/*.vue'
+      ]
+    }
+  }
+})
+```
+
+### Custom Scalars
+
+```ts
+import { GraphQLScalarType } from 'graphql'
+import { Kind } from 'graphql/language'
+// server/graphql/scalars/DateTime.ts
+import { createResolver } from 'nitro-graphql'
+
+export default createResolver({
+  DateTime: new GraphQLScalarType({
+    name: 'DateTime',
+    serialize: (value: Date) => value.toISOString(),
+    parseValue: (value: string) => new Date(value),
+    parseLiteral: (ast) => {
+      if (ast.kind === Kind.STRING) {
+        return new Date(ast.value)
+      }
+      return null
+    }
+  })
+})
+```
+
+### Error Handling
+
+```ts
+// server/graphql/users/user-queries.ts
+import { createResolver } from 'nitro-graphql'
+
+export default createResolver({
+  Query: {
+    user: async (_, { id }, { storage }) => {
+      try {
+        const user = await storage.getItem(`user:${id}`)
+        if (!user) {
+          throw new Error(`User with id ${id} not found`)
+        }
+        return user
+      }
+      catch (error) {
+        console.error('[graphql] Error fetching user:', error)
+        throw error
+      }
+    }
+  }
+})
+```
+
+## Performance
+
+### Bundle Size
+The module is optimized for minimal bundle size:
+- Development dependencies are excluded from production builds
+- Uses Function constructor for dynamic imports to prevent bundling
+- Efficient chunk organization
+
+### Caching
+- Built-in cache headers for Apollo Sandbox (1 week)
+- Configurable cache settings
+- Lazy schema initialization
+
+## Community & Contributing
+
+> [!TIP]
+> **Want to contribute?** We believe you can play a role in the growth of this project!
+
+### 🎯 How You Can Contribute
+
+- **💡 Share your ideas**: Use [GitHub Issues](https://github.com/productdevbook/nitro-graphql/issues) for new feature suggestions
+- **🐛 Report bugs**: Report issues you encounter in detail
+- **📖 Improve documentation**: Enhance README, examples, and guides
+- **🔧 Code contributions**: Develop bug fixes and new features
+- **🌟 Support the project**: Support the project by giving it a star
+
+### 💬 Discussion and Support
+
+- **GitHub Issues**: Feature requests and bug reports
+- **GitHub Discussions**: General discussions and questions
+- **Pull Requests**: Code contributions
+
+### 🚀 Contribution Process
+
+1. **Open an issue**: Let's discuss what you want to do first
+2. **Fork & Branch**: Fork the project and create a feature branch
+3. **Write code**: Develop according to existing code standards
+4. **Test**: Test your changes
+5. **Send PR**: Create a pull request with detailed description
+
+> [!IMPORTANT]
+> Please don't forget to read the [Contribution Guidelines](CONTRIBUTING.md) document before contributing.
+
+---
+
+### 🌟 Thank You
+
+Thank you for using and developing this project. Every contribution makes the GraphQL ecosystem stronger!
+
+## License
+
+MIT

package/dist/client-codegen-DM2n5Gt2.js

@@ -0,0 +1,86 @@
+import { consola } from "consola";
+import { codegen } from "@graphql-codegen/core";
+import { plugin } from "@graphql-codegen/typescript";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { defu } from "defu";
+import { parse } from "graphql";
+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 } from "@graphql-tools/load";
+
+//#region src/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 loadGraphQLDocuments(patterns) {
+	try {
+		const result = await loadDocuments(patterns, { loaders: [new GraphQLFileLoader()] });
+		return result;
+	} 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, patterns, config = {}, outputPath) {
+	const docs = await loadGraphQLDocuments(patterns);
+	if (docs.length === 0) {
+		consola.info("[graphql] No client GraphQL files found. Skipping client type generation.");
+		return "";
+	}
+	consola.info(`[graphql] Found ${docs.length} client GraphQL documents`);
+	const defaultConfig = {
+		documentMode: "string",
+		emitLegacyCommonJSImports: false,
+		useTypeImports: true,
+		enumsAsTypes: true,
+		strictScalars: true,
+		maybeValue: "T | null | undefined",
+		inputMaybeValue: "T | undefined",
+		scalars: {
+			DateTime: "string",
+			JSON: "any",
+			UUID: "string",
+			NonEmptyString: "string",
+			Currency: "string"
+		}
+	};
+	const mergedConfig = defu(config, defaultConfig);
+	try {
+		const output = await codegen({
+			filename: outputPath || "client-types.generated.ts",
+			schema: parse(printSchemaWithDirectives(schema)),
+			documents: [...docs],
+			config: mergedConfig,
+			plugins: [
+				{ pluginContent: {} },
+				{ typescript: {} },
+				{ typescriptOperations: {} },
+				{ typescriptGenericSdk: { rawRequest: false } }
+			],
+			pluginMap: {
+				pluginContent: { plugin: pluginContent },
+				typescript: { plugin },
+				typescriptOperations: { plugin: plugin$2 },
+				typescriptGenericSdk: { plugin: plugin$1 }
+			}
+		});
+		return output;
+	} catch (error) {
+		consola.warn("[graphql] Client type generation failed:", error);
+		return "";
+	}
+}
+
+//#endregion
+export { generateClientTypes };
+//# sourceMappingURL=client-codegen-DM2n5Gt2.js.map

package/dist/client-codegen-DM2n5Gt2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-codegen-DM2n5Gt2.js","names":["_schema: any","_documents: any","_config: any","_info: any","patterns: string | string[]","e: any","schema: GraphQLSchema","config: CodegenClientConfig","outputPath?: string","defaultConfig: CodegenClientConfig","typescriptPlugin","typescriptOperations","typescriptGenericSdk"],"sources":["../src/client-codegen.ts"],"sourcesContent":["import type { GraphQLSchema } from 'graphql'\nimport type { CodegenClientConfig } from './types'\nimport { codegen } from '@graphql-codegen/core'\nimport { plugin as typescriptPlugin } from '@graphql-codegen/typescript'\nimport { plugin as typescriptGenericSdk } from '@graphql-codegen/typescript-generic-sdk'\nimport { plugin as typescriptOperations } from '@graphql-codegen/typescript-operations'\nimport { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader'\nimport { loadDocuments } from '@graphql-tools/load'\nimport { printSchemaWithDirectives } from '@graphql-tools/utils'\nimport { consola } from 'consola'\nimport { defu } from 'defu'\nimport { parse } from 'graphql'\n\nfunction pluginContent(_schema: any, _documents: any, _config: any, _info: any) {\n  return {\n    prepend: [\n      '// THIS FILE IS GENERATED, DO NOT EDIT!',\n      '/* eslint-disable eslint-comments/no-unlimited-disable */',\n      '/* tslint:disable */',\n      '/* eslint-disable */',\n      '/* prettier-ignore */',\n    ],\n    content: '',\n  }\n}\n\nasync function loadGraphQLDocuments(patterns: string | string[]) {\n  try {\n    const result = await loadDocuments(patterns, {\n      loaders: [new GraphQLFileLoader()],\n    })\n    return result\n  }\n  catch (e: any) {\n    if (\n      (e.message || '').includes(\n        'Unable to find any GraphQL type definitions for the following pointers:',\n      )\n    ) {\n      // No GraphQL files found - this is normal\n      return []\n    }\n    else {\n      // Re-throw other errors\n      throw e\n    }\n  }\n}\n\nexport async function generateClientTypes(\n  schema: GraphQLSchema,\n  patterns: string | string[],\n  config: CodegenClientConfig = {},\n  outputPath?: string,\n) {\n  const docs = await loadGraphQLDocuments(patterns)\n\n  if (docs.length === 0) {\n    consola.info('[graphql] No client GraphQL files found. Skipping client type generation.')\n    return ''\n  }\n\n  consola.info(`[graphql] Found ${docs.length} client GraphQL documents`)\n\n  const defaultConfig: CodegenClientConfig = {\n    documentMode: 'string',\n    emitLegacyCommonJSImports: false,\n    useTypeImports: true,\n    enumsAsTypes: true,\n    strictScalars: true,\n    maybeValue: 'T | null | undefined',\n    inputMaybeValue: 'T | undefined',\n    scalars: {\n      DateTime: 'string',\n      JSON: 'any',\n      UUID: 'string',\n      NonEmptyString: 'string',\n      Currency: 'string',\n    },\n  }\n\n  const mergedConfig = defu(config, defaultConfig)\n\n  try {\n    const output = await codegen({\n      filename: outputPath || 'client-types.generated.ts',\n      schema: parse(printSchemaWithDirectives(schema)),\n      documents: [...docs],\n      config: mergedConfig,\n      plugins: [\n        { pluginContent: {} },\n        { typescript: {} },\n        { typescriptOperations: {} },\n        { typescriptGenericSdk: { rawRequest: false } },\n      ],\n      pluginMap: {\n        pluginContent: { plugin: pluginContent },\n        typescript: { plugin: typescriptPlugin },\n        typescriptOperations: { plugin: typescriptOperations },\n        typescriptGenericSdk: { plugin: typescriptGenericSdk },\n      },\n    })\n\n    return output\n  }\n  catch (error) {\n    consola.warn('[graphql] Client type generation failed:', error)\n    return ''\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAaA,SAAS,cAAcA,SAAcC,YAAiBC,SAAcC,OAAY;AAC9E,QAAO;EACL,SAAS;GACP;GACA;GACA;GACA;GACA;EACD;EACD,SAAS;CACV;AACF;AAED,eAAe,qBAAqBC,UAA6B;AAC/D,KAAI;EACF,MAAM,SAAS,MAAM,cAAc,UAAU,EAC3C,SAAS,CAAC,IAAI,mBAAoB,EACnC,EAAC;AACF,SAAO;CACR,SACMC,GAAQ;AACb,MACE,CAAC,EAAE,WAAW,IAAI,SAChB,0EACD,CAGD,QAAO,CAAE;MAIT,OAAM;CAET;AACF;AAED,eAAsB,oBACpBC,QACAF,UACAG,SAA8B,CAAE,GAChCC,YACA;CACA,MAAM,OAAO,MAAM,qBAAqB,SAAS;AAEjD,KAAI,KAAK,WAAW,GAAG;AACrB,UAAQ,KAAK,4EAA4E;AACzF,SAAO;CACR;AAED,SAAQ,KAAK,CAAC,gBAAgB,EAAE,KAAK,OAAO,yBAAyB,CAAC,CAAC;CAEvE,MAAMC,gBAAqC;EACzC,cAAc;EACd,2BAA2B;EAC3B,gBAAgB;EAChB,cAAc;EACd,eAAe;EACf,YAAY;EACZ,iBAAiB;EACjB,SAAS;GACP,UAAU;GACV,MAAM;GACN,MAAM;GACN,gBAAgB;GAChB,UAAU;EACX;CACF;CAED,MAAM,eAAe,KAAK,QAAQ,cAAc;AAEhD,KAAI;EACF,MAAM,SAAS,MAAM,QAAQ;GAC3B,UAAU,cAAc;GACxB,QAAQ,MAAM,0BAA0B,OAAO,CAAC;GAChD,WAAW,CAAC,GAAG,IAAK;GACpB,QAAQ;GACR,SAAS;IACP,EAAE,eAAe,CAAE,EAAE;IACrB,EAAE,YAAY,CAAE,EAAE;IAClB,EAAE,sBAAsB,CAAE,EAAE;IAC5B,EAAE,sBAAsB,EAAE,YAAY,MAAO,EAAE;GAChD;GACD,WAAW;IACT,eAAe,EAAE,QAAQ,cAAe;IACxC,YAAY,EAAUC,OAAkB;IACxC,sBAAsB,EAAE,QAAQC,SAAsB;IACtD,sBAAsB,EAAE,QAAQC,SAAsB;GACvD;EACF,EAAC;AAEF,SAAO;CACR,SACM,OAAO;AACZ,UAAQ,KAAK,4CAA4C,MAAM;AAC/D,SAAO;CACR;AACF"}

package/dist/client-watcher.d.ts

@@ -0,0 +1,10 @@
+import { NitroGraphQLOptions } from "./types-D_NqyCcy.js";
+import { Nitro } from "nitropack/types";
+
+//#region src/client-watcher.d.ts
+declare function setupClientWatcher(nitro: Nitro, options: NitroGraphQLOptions): Promise<void>;
+//# sourceMappingURL=client-watcher.d.ts.map
+
+//#endregion
+export { setupClientWatcher };
+//# sourceMappingURL=client-watcher.d.ts.map

package/dist/client-watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-watcher.d.ts","names":[],"sources":["../src/client-watcher.ts"],"sourcesContent":[],"mappings":";;;;iBAmEsB,kBAAA,QAA0B,gBAAgB,sBAAmB"}

package/dist/client-watcher.js

@@ -0,0 +1,92 @@
+import { scanGraphQLFiles } from "./scanner-BdcKEPQk.js";
+import { debounce } from "./utils-87_22aIA.js";
+import { mkdir, writeFile } from "node:fs/promises";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+import { makeExecutableSchema } from "@graphql-tools/schema";
+import { consola } from "consola";
+import { join } from "pathe";
+
+//#region src/client-watcher.ts
+const logger = consola.withTag("graphql");
+async function regenerateClientTypes(nitro, options) {
+	try {
+		if (!options.client?.enabled) return;
+		const scanResult = await scanGraphQLFiles(nitro);
+		if (scanResult.typeDefs.length === 0) {
+			logger.warn("⚠️  No server schema found for client type generation");
+			return;
+		}
+		const mergedTypeDefs = mergeTypeDefs(scanResult.typeDefs);
+		const schema = makeExecutableSchema({
+			typeDefs: mergedTypeDefs,
+			resolvers: {}
+		});
+		const clientPatterns = options.client.watchPatterns || [
+			join(nitro.options.srcDir, "**/*.graphql"),
+			join(nitro.options.srcDir, "**/*.gql"),
+			`!${join(nitro.options.srcDir, "graphql/**/*")}`
+		];
+		const { generateClientTypes } = await import("./client-codegen-DM2n5Gt2.js");
+		const generatedTypes = await generateClientTypes(schema, clientPatterns, options.client.config, options.client.outputPath);
+		if (generatedTypes) {
+			const outputPath = options.client.outputPath || join(nitro.options.buildDir, "types", "graphql-client.generated.ts");
+			const typesDir = join(nitro.options.buildDir, "types");
+			await mkdir(typesDir, { recursive: true });
+			await writeFile(outputPath, generatedTypes);
+			logger.success("✨ Client types updated");
+		}
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.error("❌ Client type generation failed:", errorMessage);
+	}
+}
+async function setupClientWatcher(nitro, options) {
+	if (!options.client?.enabled) {
+		logger.info("🚫 Client type generation disabled");
+		return;
+	}
+	const clientPatterns = options.client.watchPatterns || [join(nitro.options.srcDir, "**/*.graphql"), join(nitro.options.srcDir, "**/*.gql")];
+	const generateClientTypesDebounced = debounce(async () => {
+		await regenerateClientTypes(nitro, options);
+	}, 300);
+	const { watch } = await import("chokidar");
+	const { globby } = await import("globby");
+	const existingClientFiles = await globby(clientPatterns, {
+		absolute: true,
+		ignore: [join(nitro.options.srcDir, "graphql/**/*")]
+	});
+	const watchPatterns = existingClientFiles.length > 0 ? existingClientFiles : clientPatterns;
+	const watcher = watch(watchPatterns, {
+		persistent: true,
+		ignoreInitial: true,
+		ignored: /(^|[/\\])\../,
+		followSymlinks: false,
+		depth: 10,
+		usePolling: true,
+		interval: 1e3,
+		binaryInterval: 1e3
+	});
+	watcher.on("change", (_path) => {
+		generateClientTypesDebounced();
+	});
+	watcher.on("add", (_path) => {
+		generateClientTypesDebounced();
+	});
+	watcher.on("unlink", (_path) => {
+		generateClientTypesDebounced();
+	});
+	watcher.on("error", (error) => {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.error("❌ Client watcher error:", errorMessage);
+	});
+	nitro.hooks.hook("close", () => {
+		logger.info("🔒 Closing client watcher");
+		watcher.close();
+	});
+	await generateClientTypesDebounced();
+	logger.success("✅ Client watcher ready");
+}
+
+//#endregion
+export { setupClientWatcher };
+//# sourceMappingURL=client-watcher.js.map