nitro-graphql 0.0.1 → 0.0.3

package/README.md

@@ -111,9 +111,9 @@ extend type Mutation {
 #### Domain-based Resolver Files
 ```ts
 // server/graphql/users/user-queries.ts
-import { createResolver } from 'nitro-graphql'
+import { defineResolver } from 'nitro-graphql'
 
-export default createResolver({
+export default defineResolver({
   Query: {
     users: async (_, __, { storage }) => {
       return await storage.getItem('users') || []
@@ -128,9 +128,9 @@ export default createResolver({
 
 ```ts
 // server/graphql/users/create-user.ts
-import { createResolver } from 'nitro-graphql'
+import { defineResolver } from 'nitro-graphql'
 
-export default createResolver({
+export default defineResolver({
   Mutation: {
     createUser: async (_, { input }, { storage }) => {
       const users = await storage.getItem('users') || []
@@ -153,9 +153,9 @@ The module provides utilities for better developer experience:
 
 ```ts
 // server/graphql/hello.ts
-import { createResolver } from 'nitro-graphql'
+import { defineResolver } from 'nitro-graphql'
 
-export default createResolver({
+export default defineResolver({
   Query: {
     hello: () => 'Hello World!',
     greeting: (_, { name }) => `Hello ${name}!`
@@ -175,9 +175,9 @@ 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'
+import { defineResolver } from 'nitro-graphql'
 
-export default createResolver({
+export default defineResolver({
   Query: {
     users: async (_, __, { storage }): Promise<User[]> => {
       return await storage.getItem('users') || []
@@ -222,9 +222,9 @@ The GraphQL context includes:
 
 ```ts
 // Example resolver with full context usage
-import { createResolver } from 'nitro-graphql'
+import { defineResolver } from 'nitro-graphql'
 
-export default createResolver({
+export default defineResolver({
   Query: {
     currentUser: async (_, __, { event, request, storage }) => {
       const token = getCookie(event, 'auth-token')
@@ -380,9 +380,9 @@ export default defineNitroConfig({
 import { GraphQLScalarType } from 'graphql'
 import { Kind } from 'graphql/language'
 // server/graphql/scalars/DateTime.ts
-import { createResolver } from 'nitro-graphql'
+import { defineResolver } from 'nitro-graphql'
 
-export default createResolver({
+export default defineResolver({
   DateTime: new GraphQLScalarType({
     name: 'DateTime',
     serialize: (value: Date) => value.toISOString(),
@@ -401,9 +401,9 @@ export default createResolver({
 
 ```ts
 // server/graphql/users/user-queries.ts
-import { createResolver } from 'nitro-graphql'
+import { defineResolver } from 'nitro-graphql'
 
-export default createResolver({
+export default defineResolver({
   Query: {
     user: async (_, { id }, { storage }) => {
       try {

package/dist/{client-codegen-DM2n5Gt2.js → client-codegen.js}

@@ -82,5 +82,4 @@ async function generateClientTypes(schema, patterns, config = {}, outputPath) {
 }
 
 //#endregion
-export { generateClientTypes };
-//# sourceMappingURL=client-codegen-DM2n5Gt2.js.map
+export { generateClientTypes };

package/dist/client-watcher.d.ts

@@ -1,10 +1,7 @@
-import { NitroGraphQLOptions } from "./types-D_NqyCcy.js";
+import { NitroGraphQLOptions } from "./types.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
+export { setupClientWatcher };

package/dist/client-watcher.js

@@ -1,10 +1,10 @@
-import { scanGraphQLFiles } from "./scanner-BdcKEPQk.js";
-import { debounce } from "./utils-87_22aIA.js";
+import { scanGraphQLFiles } from "./scanner.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";
+import { debounce } from "perfect-debounce";
 
 //#region src/client-watcher.ts
 const logger = consola.withTag("graphql");
@@ -21,12 +21,19 @@ async function regenerateClientTypes(nitro, options) {
 			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 getClientPatterns = () => {
+			if (options.client?.watchPatterns) return options.client.watchPatterns;
+			const basePatterns = [
+				join(nitro.options.srcDir, "**/*.graphql"),
+				join(nitro.options.srcDir, "**/*.gql"),
+				`!${join(nitro.options.srcDir, "graphql/**/*")}`
+			];
+			if (nitro.options.framework?.name === "nuxt") if (options.client?.nuxtPatterns) basePatterns.unshift(...options.client.nuxtPatterns);
+			else basePatterns.unshift(join(nitro.options.srcDir, "app/graphql/**/*.graphql"), join(nitro.options.srcDir, "app/graphql/**/*.gql"));
+			return basePatterns;
+		};
+		const clientPatterns = getClientPatterns();
+		const { generateClientTypes } = await import("./client-codegen.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");
@@ -45,48 +52,49 @@ async function setupClientWatcher(nitro, options) {
 		logger.info("🚫 Client type generation disabled");
 		return;
 	}
-	const clientPatterns = options.client.watchPatterns || [join(nitro.options.srcDir, "**/*.graphql"), join(nitro.options.srcDir, "**/*.gql")];
+	const getClientPatterns = () => {
+		if (options.client?.watchPatterns) return options.client.watchPatterns;
+		const basePatterns = [join(nitro.options.srcDir, "**/*.graphql"), join(nitro.options.srcDir, "**/*.gql")];
+		if (nitro.options.framework?.name === "nuxt") if (options.client?.nuxtPatterns) basePatterns.unshift(...options.client.nuxtPatterns);
+		else basePatterns.unshift(join(nitro.options.srcDir, "app/graphql/**/*.graphql"), join(nitro.options.srcDir, "app/graphql/**/*.gql"));
+		return basePatterns;
+	};
+	const clientPatterns = getClientPatterns();
 	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, {
+	const watcher = watch(clientPatterns, {
 		persistent: true,
 		ignoreInitial: true,
-		ignored: /(^|[/\\])\../,
+		ignored: [/(^|[/\\])\.\.\./, join(nitro.options.srcDir, "graphql/**/*")],
 		followSymlinks: false,
-		depth: 10,
 		usePolling: true,
-		interval: 1e3,
-		binaryInterval: 1e3
+		interval: 500,
+		binaryInterval: 500
 	});
-	watcher.on("change", (_path) => {
+	watcher.on("add", (path) => {
+		logger.info(`📁 Client file added: ${path}`);
 		generateClientTypesDebounced();
 	});
-	watcher.on("add", (_path) => {
+	watcher.on("change", (path) => {
+		logger.info(`📝 Client file changed: ${path}`);
 		generateClientTypesDebounced();
 	});
-	watcher.on("unlink", (_path) => {
+	watcher.on("unlink", (path) => {
+		logger.info(`🗑️ Client file removed: ${path}`);
 		generateClientTypesDebounced();
 	});
 	watcher.on("error", (error) => {
-		const errorMessage = error instanceof Error ? error.message : String(error);
-		logger.error("❌ Client watcher error:", errorMessage);
+		logger.error("❌ Client watcher error:", error);
 	});
 	nitro.hooks.hook("close", () => {
 		logger.info("🔒 Closing client watcher");
 		watcher.close();
 	});
-	await generateClientTypesDebounced();
+	await regenerateClientTypes(nitro, options);
 	logger.success("✅ Client watcher ready");
 }
 
 //#endregion
-export { setupClientWatcher };
-//# sourceMappingURL=client-watcher.js.map
+export { setupClientWatcher };

package/dist/codegen.d.ts

@@ -1,2 +1,13 @@
-import { CodegenServerConfig, generateTypes } from "./codegen-DWJuLowd.js";
+import { GraphQLSchema } from "graphql";
+
+//#region src/codegen.d.ts
+interface CodegenServerConfig {
+  contextType?: string;
+  scalars?: Record<string, any>;
+  defaultMapper?: string;
+  mapperTypeSuffix?: string;
+  [key: string]: any;
+}
+declare function generateTypes(schema: GraphQLSchema, config?: CodegenServerConfig, outputPath?: string): Promise<string>;
+//#endregion
 export { CodegenServerConfig, generateTypes };

package/dist/codegen.js

@@ -1,3 +1,109 @@
-import { generateTypes } from "./codegen-Dbw6gEZt.js";
+import { codegen } from "@graphql-codegen/core";
+import * as typescriptPlugin from "@graphql-codegen/typescript";
+import * as typescriptResolversPlugin from "@graphql-codegen/typescript-resolvers";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { defu } from "defu";
+import { parse } from "graphql";
+import { CurrencyResolver, DateTimeResolver, JSONResolver, NonEmptyStringResolver, UUIDResolver } from "graphql-scalars";
 
+//#region src/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 generateTypes(schema, config = {}, outputPath) {
+	const defaultConfig = {
+		scalars: {
+			Boolean: {
+				input: "boolean",
+				output: "boolean"
+			},
+			DateTime: DateTimeResolver.extensions.codegenScalarType,
+			DateTimeISO: DateTimeResolver.extensions.codegenScalarType,
+			UUID: UUIDResolver.extensions.codegenScalarType,
+			JSON: JSONResolver.extensions.codegenScalarType,
+			JSONObject: JSONResolver.extensions.codegenScalarType,
+			NonEmptyString: NonEmptyStringResolver.extensions.codegenScalarType,
+			Currency: CurrencyResolver.extensions.codegenScalarType,
+			File: {
+				input: "File",
+				output: "File"
+			},
+			Cursor: {
+				input: "number",
+				output: "number"
+			}
+		},
+		defaultScalarType: "unknown",
+		defaultMapper: `ResolverReturnType<{T}>`,
+		contextType: "./context#GraphQLContext",
+		maybeValue: "T | null | undefined",
+		inputMaybeValue: "T | undefined",
+		enumsAsTypes: true,
+		useTypeImports: true,
+		strictScalars: true,
+		emitLegacyCommonJSImports: false
+	};
+	const mergedConfig = defu(config, defaultConfig);
+	const output = await codegen({
+		filename: outputPath || "types.generated.ts",
+		schema: parse(printSchemaWithDirectives(schema)),
+		documents: [],
+		config: mergedConfig,
+		plugins: [
+			{ imports: {} },
+			{ pluginContent: {} },
+			{ typescript: {} },
+			{ typescriptResolvers: {} }
+		],
+		pluginMap: {
+			pluginContent: { plugin: pluginContent },
+			imports: { plugin: () => ({
+				prepend: [`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> = {
+  [K in keyof T]: ResolverReturnType<T[K]>
+};`, ""],
+				content: ""
+			}) },
+			typescript: typescriptPlugin,
+			typescriptResolvers: typescriptResolversPlugin
+		}
+	}).catch((e) => {
+		console.warn("[nitro-graphql] Code generation error:", e);
+		return "";
+	});
+	return output;
+}
+
+//#endregion
 export { generateTypes };

package/dist/context.d.ts

@@ -1,2 +1,10 @@
-import { GraphQLContext } from "./context-BgqNJFCT.js";
+import { YogaInitialContext } from "graphql-yoga";
+import { H3Event } from "h3";
+
+//#region src/context.d.ts
+interface GraphQLContext extends YogaInitialContext {
+  event: H3Event;
+  storage: any;
+}
+//#endregion
 export { GraphQLContext };

package/dist/context.js

@@ -1 +0,0 @@
-import "./context-CZdhkJYD.js";

package/dist/dev.js

@@ -0,0 +1,95 @@
+import { scanGraphQLFiles } from "./scanner.js";
+import { setupClientWatcher } from "./client-watcher.js";
+import { generateTypes } from "./codegen.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";
+import { debounce } from "perfect-debounce";
+import { existsSync } from "node:fs";
+import { watch } from "chokidar";
+
+//#region src/dev.ts
+const logger = consola.withTag("graphql");
+async function regenerateGraphQLTypes(nitro) {
+	try {
+		const scanResult = await scanGraphQLFiles(nitro);
+		if (scanResult.typeDefs.length === 0) {
+			logger.warn("⚠️  No schema files found");
+			return;
+		}
+		const mergedTypeDefs = mergeTypeDefs(scanResult.typeDefs);
+		const schema = makeExecutableSchema({
+			typeDefs: mergedTypeDefs,
+			resolvers: {}
+		});
+		const generatedTypes = await generateTypes(schema);
+		const outputPath = join(nitro.options.buildDir, "types", "graphql-types.generated.ts");
+		const typesDir = join(nitro.options.buildDir, "types");
+		await mkdir(typesDir, { recursive: true });
+		await writeFile(outputPath, generatedTypes);
+		logger.success("✨ Types regenerated");
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.error("❌ Type generation failed:", errorMessage);
+	}
+}
+function devmode(nitro, options) {
+	if (nitro.options.dev) {
+		const generateTypesDebounced = debounce(async () => {
+			await regenerateGraphQLTypes(nitro);
+		}, 100);
+		const graphqlDir = join(nitro.options.srcDir, "graphql");
+		logger.info("🔍 Setting up independent GraphQL watcher for directory:", graphqlDir);
+		try {
+			if (!existsSync(graphqlDir)) {
+				logger.warn(`⚠️ GraphQL directory not found: ${graphqlDir}`);
+				return;
+			}
+		} catch (error) {
+			logger.warn("⚠️ Could not check GraphQL directory:", error);
+			return;
+		}
+		const graphqlWatcher = watch(graphqlDir, {
+			ignoreInitial: true,
+			persistent: true,
+			usePolling: true,
+			interval: 500,
+			depth: 10
+		});
+		graphqlWatcher.on("add", (path) => {
+			logger.info("📁 GraphQL file added:", path);
+			generateTypesDebounced();
+		});
+		graphqlWatcher.on("change", (path) => {
+			logger.info("📝 GraphQL file changed:", path);
+			generateTypesDebounced();
+		});
+		graphqlWatcher.on("unlink", (path) => {
+			logger.info("🗑️ GraphQL file deleted:", path);
+			generateTypesDebounced();
+		});
+		graphqlWatcher.on("error", (error) => {
+			logger.error("❌ GraphQL watcher error:", error);
+		});
+		graphqlWatcher.on("raw", (event, path) => {
+			if (event === "change" && path && path.endsWith("graphql")) {
+				logger.info("📝 GraphQL directory change detected, regenerating types");
+				generateTypesDebounced();
+			}
+		});
+		graphqlWatcher.on("ready", () => {
+			logger.success("✅ GraphQL file watcher ready");
+		});
+		nitro.hooks.hook("close", async () => {
+			await graphqlWatcher.close();
+			logger.info("🔒 GraphQL watcher closed");
+		});
+		setupClientWatcher(nitro, options);
+		logger.success("✅ Independent GraphQL watcher set up");
+	}
+}
+
+//#endregion
+export { devmode };

package/dist/index.d.ts

@@ -1,11 +1,15 @@
-import { CodegenClientConfig, GraphQLSchemaConfig, NitroGraphQLOptions, Resolvers } from "./types-D_NqyCcy.js";
-import { CodegenServerConfig, generateTypes } from "./codegen-DWJuLowd.js";
-import { GraphQLContext } from "./context-BgqNJFCT.js";
-import { createResolver, defineGraphQLResolver, defineYogaConfig } from "./utils-BuYDOLIi.js";
-import * as nitropack0 from "nitropack";
+import { NitroGraphQLOptions } from "./types.js";
+import * as nitropack1 from "nitropack";
 
 //#region src/index.d.ts
-declare const _default: nitropack0.NitroModule;
+declare module 'nitropack' {
+  interface NitroOptions {
+    graphqlYoga?: NitroGraphQLOptions;
+  }
+  interface NitroRuntimeConfig {
+    graphqlYoga?: NitroGraphQLOptions;
+  }
+}
+declare const _default: nitropack1.NitroModule;
 //#endregion
-export { CodegenClientConfig, CodegenServerConfig, GraphQLContext, GraphQLSchemaConfig, NitroGraphQLOptions, Resolvers, createResolver, _default as default, defineGraphQLResolver, defineYogaConfig, generateTypes };
-//# sourceMappingURL=index.d.ts.map
+export { _default as default };