nitro-graphql 1.2.0 → 1.2.2

package/dist/ecosystem/nuxt.d.ts

@@ -1,7 +1,7 @@
-import * as _nuxt_schema3 from "@nuxt/schema";
+import * as _nuxt_schema0 from "@nuxt/schema";
 
 //#region src/ecosystem/nuxt.d.ts
 interface ModuleOptions {}
-declare const _default: _nuxt_schema3.NuxtModule<ModuleOptions, ModuleOptions, false>;
+declare const _default: _nuxt_schema0.NuxtModule<ModuleOptions, ModuleOptions, false>;
 //#endregion
 export { ModuleOptions, _default as default };

package/dist/ecosystem/nuxt.js

@@ -1,3 +1,4 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join, resolve } from "pathe";
 import { defineNuxtModule } from "@nuxt/kit";
 
@@ -31,6 +32,27 @@ var nuxt_default = defineNuxtModule({
 		nuxt.hook("imports:dirs", (dirs) => {
 			dirs.push(resolve(nuxt.options.srcDir, "graphql"));
 		});
+		nuxt.hook("nitro:config", () => {
+			const clientDir = join(nuxt.options.buildDir, "graphql");
+			const appGraphqlDir = resolve(nuxt.options.rootDir, "app/graphql");
+			const hasAppGraphqlDir = existsSync(appGraphqlDir);
+			if (!hasAppGraphqlDir) {
+				const defaultDir = join(clientDir, "default");
+				if (!existsSync(defaultDir)) mkdirSync(defaultDir, { recursive: true });
+				const sampleQueryFile = join(defaultDir, "queries.graphql");
+				if (!existsSync(sampleQueryFile)) writeFileSync(sampleQueryFile, `# Example GraphQL queries
+# Add your GraphQL queries here
+
+# query GetUser($id: ID!) {
+#   user(id: $id) {
+#     id
+#     name
+#     email
+#   }
+# }
+`, "utf-8");
+			}
+		});
 	}
 });
 

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { StandardSchemaV1 } from "./types/standard-schema.js";
 import { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, GenImport, GenericSdkConfig, NitroGraphQLOptions } from "./types/index.js";
-import * as nitropack2 from "nitropack";
+import * as nitropack1 from "nitropack";
 
 //#region src/index.d.ts
-declare const _default: nitropack2.NitroModule;
+declare const _default: nitropack1.NitroModule;
 //#endregion
 export { CodegenClientConfig, CodegenServerConfig, ExternalGraphQLService, GenImport, GenericSdkConfig, NitroGraphQLOptions, StandardSchemaV1, _default as default };

package/dist/index.js

@@ -71,7 +71,8 @@ var src_default = defineNitroModule({
 		}
 		if (nitro.options.graphql?.externalServices?.length) {
 			for (const service of nitro.options.graphql.externalServices) if (service.documents?.length) for (const pattern of service.documents) {
-				const baseDir = pattern.split("**")[0].replace(/\/$/, "") || ".";
+				if (!pattern) continue;
+				const baseDir = pattern.split("**")[0]?.replace(/\/$/, "") || ".";
 				const resolvedDir = resolve(nitro.options.rootDir, baseDir);
 				if (!watchDirs.includes(resolvedDir)) watchDirs.push(resolvedDir);
 			}

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

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

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

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

package/dist/utils/client-codegen.js

@@ -57,23 +57,23 @@ async function loadExternalSchema(service, buildDir) {
 		if (service.downloadSchema && buildDir) {
 			const defaultPath = resolve(buildDir, "graphql", "schemas", `${service.name}.graphql`);
 			const schemaFilePath = service.downloadPath ? resolve(service.downloadPath) : defaultPath;
-			if (existsSync(schemaFilePath)) {
-				consola$1.info(`[graphql:${service.name}] Loading schema from local file: ${schemaFilePath}`);
-				try {
-					const result$1 = loadSchemaSync([schemaFilePath], { loaders: [new GraphQLFileLoader()] });
-					consola$1.info(`[graphql:${service.name}] External schema loaded successfully from local file`);
-					return result$1;
-				} catch (localError) {
-					consola$1.warn(`[graphql:${service.name}] Failed to load local schema, falling back to remote:`, localError);
-				}
+			if (existsSync(schemaFilePath)) try {
+				const result$1 = loadSchemaSync([schemaFilePath], { loaders: [new GraphQLFileLoader()] });
+				return result$1;
+			} catch {
+				consola$1.warn(`[graphql:${service.name}] Cached schema invalid, loading from source`);
 			}
 		}
-		consola$1.info(`[graphql:${service.name}] Loading external schema from: ${schemas.join(", ")}`);
+		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");
 		const result = loadSchemaSync(schemas, {
-			loaders: [new GraphQLFileLoader(), new UrlLoader()],
+			loaders,
 			...Object.keys(headers).length > 0 && { headers }
 		});
-		consola$1.info(`[graphql:${service.name}] External schema loaded successfully`);
 		return result;
 	} catch (error) {
 		consola$1.error(`[graphql:${service.name}] Failed to load external schema:`, error);
@@ -81,6 +81,12 @@ async function loadExternalSchema(service, buildDir) {
 	}
 }
 /**
+* 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) {
@@ -91,12 +97,14 @@ async function downloadAndSaveSchema(service, buildDir) {
 	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) try {
-				const remoteSchema = loadSchemaSync(schemas, {
+			if (fileExists && hasUrlSchemas) try {
+				const remoteSchema = loadSchemaSync(schemas.filter(isUrl), {
 					loaders: [new UrlLoader()],
 					...Object.keys(headers).length > 0 && { headers }
 				});
@@ -112,24 +120,48 @@ async function downloadAndSaveSchema(service, buildDir) {
 				consola$1.warn(`[graphql:${service.name}] Unable to compare with remote schema, updating local cache`);
 				shouldDownload = true;
 			}
-		} else if (downloadMode === true || downloadMode === "once") {
-			shouldDownload = !fileExists;
-			if (fileExists) consola$1.info(`[graphql:${service.name}] Using cached schema from: ${schemaFilePath}`);
-		}
+			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) {
-			consola$1.info(`[graphql:${service.name}] Downloading schema to: ${schemaFilePath}`);
-			const schema = loadSchemaSync(schemas, {
-				loaders: [new UrlLoader()],
-				...Object.keys(headers).length > 0 && { headers }
-			});
-			const schemaString = printSchemaWithDirectives(schema);
-			mkdirSync(dirname(schemaFilePath), { recursive: true });
-			writeFileSync(schemaFilePath, schemaString, "utf-8");
-			consola$1.success(`[graphql:${service.name}] Schema downloaded and saved successfully`);
+			if (hasUrlSchemas && hasLocalSchemas) {
+				const schema = loadSchemaSync(schemas, {
+					loaders: [new GraphQLFileLoader(), new UrlLoader()],
+					...Object.keys(headers).length > 0 && { headers }
+				});
+				const schemaString = printSchemaWithDirectives(schema);
+				mkdirSync(dirname(schemaFilePath), { recursive: true });
+				writeFileSync(schemaFilePath, schemaString, "utf-8");
+			} else if (hasUrlSchemas) {
+				const schema = loadSchemaSync(schemas, {
+					loaders: [new UrlLoader()],
+					...Object.keys(headers).length > 0 && { headers }
+				});
+				const schemaString = printSchemaWithDirectives(schema);
+				mkdirSync(dirname(schemaFilePath), { recursive: true });
+				writeFileSync(schemaFilePath, schemaString, "utf-8");
+			} else if (hasLocalSchemas) {
+				const schema = loadSchemaSync(schemas, { loaders: [new GraphQLFileLoader()] });
+				const schemaString = printSchemaWithDirectives(schema);
+				mkdirSync(dirname(schemaFilePath), { recursive: true });
+				writeFileSync(schemaFilePath, schemaString, "utf-8");
+			}
 		}
 		return schemaFilePath;
 	} catch (error) {
-		consola$1.error(`[graphql:${service.name}] Failed to download schema:`, error);
+		consola$1.error(`[graphql:${service.name}] Failed to download/copy schema:`, error);
 		return void 0;
 	}
 }
@@ -143,13 +175,11 @@ async function loadGraphQLDocuments(patterns) {
 	}
 }
 async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, outputPath, serviceName) {
-	if (docs.length === 0) {
-		const serviceLabel$1 = serviceName ? `:${serviceName}` : "";
-		consola$1.info(`[graphql${serviceLabel$1}] No client GraphQL files found. Skipping client type generation.`);
+	if (docs.length === 0 && !serviceName) {
+		consola$1.info("No client GraphQL files found. Skipping client type generation.");
 		return false;
 	}
 	const serviceLabel = serviceName ? `:${serviceName}` : "";
-	consola$1.info(`[graphql${serviceLabel}] Found ${docs.length} client GraphQL documents`);
 	const defaultConfig = {
 		emitLegacyCommonJSImports: false,
 		useTypeImports: true,
@@ -178,6 +208,48 @@ async function generateClientTypes(schema, docs, config = {}, sdkConfig = {}, ou
 	const mergedConfig = defu$1(defaultConfig, config);
 	const mergedSdkConfig = defu$1(mergedConfig, sdkConfig);
 	try {
+		if (docs.length === 0) {
+			const output$1 = await codegen({
+				filename: outputPath || "client-types.generated.ts",
+				schema: parse(printSchemaWithDirectives(schema)),
+				documents: [],
+				config: mergedConfig,
+				plugins: [{ pluginContent: {} }, { typescript: {} }],
+				pluginMap: {
+					pluginContent: { plugin: pluginContent },
+					typescript: { plugin }
+				}
+			});
+			const sdkContent$1 = `// 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)
+    }
+  }
+}
+`;
+			return {
+				types: output$1,
+				sdk: sdkContent$1
+			};
+		}
 		const output = await codegen({
 			filename: outputPath || "client-types.generated.ts",
 			schema: parse(printSchemaWithDirectives(schema)),

package/dist/utils/type-generation.js

@@ -116,7 +116,8 @@ async function serverTypeGeneration(app) {
 }
 async function clientTypeGeneration(nitro) {
 	try {
-		await generateMainClientTypes(nitro);
+		const hasServerSchema = nitro.scanSchemas && nitro.scanSchemas.length > 0;
+		if (hasServerSchema) await generateMainClientTypes(nitro);
 		if (nitro.options.graphql?.externalServices?.length) await generateExternalServicesTypes(nitro);
 	} catch (error) {
 		consola.error("Client schema generation error:", error);
@@ -171,7 +172,9 @@ async function generateMainClientTypes(nitro) {
 	mkdirSync(defaultServiceDir, { recursive: true });
 	writeFileSync(sdkTypesPath, types.sdk, "utf-8");
 	if (nitro.options.framework?.name === "nuxt") {
-		generateNuxtOfetchClient(nitro.graphql.clientDir, "default");
+		const appGraphqlDir = resolve(nitro.options.rootDir, "app/graphql");
+		const hasUserGraphqlSetup = existsSync(appGraphqlDir);
+		if (!hasUserGraphqlSetup) generateNuxtOfetchClient(nitro.graphql.clientDir, "default");
 		const externalServices = nitro.options.graphql?.externalServices || [];
 		generateGraphQLIndexFile(nitro.graphql.clientDir, externalServices);
 	}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nitro-graphql",
   "type": "module",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "GraphQL integration for Nitro",
   "license": "MIT",
   "sideEffects": false,