nitro-graphql 2.0.0-beta.24 → 2.0.0-beta.26

package/dist/utils/index.mjs

@@ -1,6 +1,7 @@
 import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.mjs";
+import { createDefaultMaskError } from "./errors.mjs";
 import { readFile } from "node:fs/promises";
-import { join, relative } from "pathe";
+import { basename, join, relative } from "pathe";
 import { hash } from "ohash";
 import { parseAsync } from "oxc-parser";
 import { glob } from "tinyglobby";
@@ -76,6 +77,17 @@ async function scanResolvers(nitro) {
 	for (const file of files) try {
 		const fileContent = await readFile(file.fullPath, "utf-8");
 		const parsed = await parseAsync(file.fullPath, fileContent);
+		if (parsed.errors && parsed.errors.length > 0) {
+			if (nitro.options.dev) {
+				const fileName = basename(file.fullPath);
+				const firstError = parsed.errors[0];
+				const location = firstError.labels?.[0];
+				const lineInfo = location ? `:${location.start}` : "";
+				const message = firstError.message.split(",")[0];
+				console.error(`✖ ${fileName}${lineInfo} - ${message}`);
+			}
+			continue;
+		}
 		const exports = {
 			imports: [],
 			specifier: file.fullPath
@@ -125,7 +137,6 @@ async function scanResolvers(nitro) {
 			}
 		}
 		if (nitro.options.dev) {
-			const relPath = relative(nitro.options.rootDir, file.fullPath);
 			if (hasDefaultExport && !hasNamedExport) nitro.logger.warn(`[nitro-graphql] ${relPath}: Using default export instead of named export. Resolvers must use named exports like "export const myResolver = defineQuery(...)". Default exports are not detected.`);
 			if (exports.imports.length === 0 && hasNamedExport) {
 				const validFunctions = VALID_DEFINE_FUNCTIONS.join(", ");
@@ -135,8 +146,8 @@ async function scanResolvers(nitro) {
 		}
 		if (exports.imports.length > 0) exportName.push(exports);
 	} catch (error) {
-		const relPath = relative(nitro.options.rootDir, file.fullPath);
-		nitro.logger.error(`[nitro-graphql] Failed to parse resolver file ${relPath}:`, error);
+		const relPath$1 = relative(nitro.options.rootDir, file.fullPath);
+		nitro.logger.error(`[nitro-graphql] Failed to parse resolver file ${relPath$1}:`, error);
 	}
 	return exportName;
 }
@@ -275,4 +286,4 @@ async function scanDir(nitro, dir, name, globPattern = GLOB_SCAN_PATTERN) {
 }
 
 //#endregion
-export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, validateExternalServices };
+export { GLOB_SCAN_PATTERN, createDefaultMaskError, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, generateLayerIgnorePatterns, getImportId, getLayerAppDirectories, getLayerDirectories, getLayerServerDirectories, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, validateExternalServices };

package/dist/utils/server-codegen.mjs

@@ -61,7 +61,7 @@ async function generateTypes(selectFremework, schema, config = {}, outputPath) {
 				return {
 					prepend: [
 						`import schemas from '#graphql/schema'`,
-						`import type { StandardSchemaV1 } from 'nitro-graphql'`,
+						`import type { StandardSchemaV1 } from 'nitro-graphql/types'`,
 						`
 export interface NPMConfig {
   framework: '${selectFremework || "graphql-yoga"}';

package/dist/utils/type-generation.d.mts

@@ -1,7 +1,12 @@
 import { Nitro } from "nitro/types";
 
 //#region src/utils/type-generation.d.ts
-declare function serverTypeGeneration(app: Nitro): Promise<void>;
-declare function clientTypeGeneration(nitro: Nitro): Promise<void>;
+declare function serverTypeGeneration(app: Nitro, options?: {
+  silent?: boolean;
+}): Promise<void>;
+declare function clientTypeGeneration(nitro: Nitro, options?: {
+  silent?: boolean;
+  isInitial?: boolean;
+}): Promise<void>;
 //#endregion
 export { clientTypeGeneration, serverTypeGeneration };

package/dist/utils/type-generation.mjs

@@ -12,6 +12,7 @@ import { mergeTypeDefs } from "@graphql-tools/merge";
 import { printSchemaWithDirectives } from "@graphql-tools/utils";
 
 //#region src/utils/type-generation.ts
+const logger = consola.withTag("nitro-graphql");
 function generateGraphQLIndexFile(nitro, clientDir, externalServices = []) {
 	if (!shouldGenerateClientUtils(nitro)) return;
 	const placeholders = getDefaultPaths(nitro);
@@ -238,15 +239,15 @@ function validateNoDuplicateTypes(schemas, schemaStrings) {
 	}
 	return true;
 }
-async function serverTypeGeneration(app) {
+async function serverTypeGeneration(app, options = {}) {
 	try {
 		if (!shouldGenerateTypes(app)) {
-			consola.debug("[nitro-graphql] Server type generation is disabled");
+			logger.debug("Server type generation is disabled");
 			return;
 		}
 		const schemas = app.scanSchemas || [];
 		if (!schemas.length) {
-			consola.info("No GraphQL definitions found for server type generation.");
+			if (!options.silent) consola.info("No GraphQL definitions found for server type generation.");
 			return;
 		}
 		const schemaStrings = loadFilesSync(schemas).map((schema$1) => typeof schema$1 === "string" ? schema$1 : schema$1.loc?.source?.body || "").filter(Boolean);
@@ -269,18 +270,18 @@ async function serverTypeGeneration(app) {
 		if (serverTypesPath) {
 			mkdirSync(dirname(serverTypesPath), { recursive: true });
 			writeFileSync(serverTypesPath, data, "utf-8");
-			consola.success(`[nitro-graphql] Generated server types at: ${serverTypesPath}`);
+			if (!options.silent) logger.success(`Generated server types at: ${serverTypesPath}`);
 		}
 	} catch (error) {
-		consola.error("Server schema generation error:", error);
+		logger.error("Server schema generation error:", error);
 	}
 }
-async function clientTypeGeneration(nitro) {
+async function clientTypeGeneration(nitro, options = {}) {
 	try {
-		if (nitro.scanSchemas && nitro.scanSchemas.length > 0) await generateMainClientTypes(nitro);
-		if (nitro.options.graphql?.externalServices?.length) await generateExternalServicesTypes(nitro);
+		if (nitro.scanSchemas && nitro.scanSchemas.length > 0) await generateMainClientTypes(nitro, options);
+		if (nitro.options.graphql?.externalServices?.length) await generateExternalServicesTypes(nitro, options);
 	} catch (error) {
-		consola.error("Client schema generation error:", error);
+		logger.error("Client schema generation error:", error);
 	}
 }
 /**
@@ -311,17 +312,17 @@ function checkOldStructure(clientDir) {
 🚫 The old files will cause import conflicts until moved!`);
 	}
 }
-async function generateMainClientTypes(nitro) {
+async function generateMainClientTypes(nitro, options = {}) {
 	checkOldStructure(nitro.graphql.clientDir);
 	const docs = nitro.scanDocuments;
 	const loadDocs = await loadGraphQLDocuments(docs);
 	const schemaFilePath = join(nitro.graphql.buildDir, "schema.graphql");
 	if (!existsSync(schemaFilePath)) {
-		consola.info("Schema file not ready yet for client type generation. Server types need to be generated first.");
+		if (!options.silent) consola.info("Schema file not ready yet for client type generation. Server types need to be generated first.");
 		return;
 	}
 	const graphqlString = readFileSync(schemaFilePath, "utf-8");
-	const types = await generateClientTypes(nitro.options.graphql?.federation?.enabled === true ? buildSubgraphSchema([{ typeDefs: parse(graphqlString) }]) : buildSchema(graphqlString), loadDocs, nitro.options.graphql?.codegen?.client ?? {}, nitro.options.graphql?.codegen?.clientSDK ?? {});
+	const types = await generateClientTypes(nitro.options.graphql?.federation?.enabled === true ? buildSubgraphSchema([{ typeDefs: parse(graphqlString) }]) : buildSchema(graphqlString), loadDocs, nitro.options.graphql?.codegen?.client ?? {}, nitro.options.graphql?.codegen?.clientSDK ?? {}, void 0, void 0, void 0, options);
 	if (types === false) return;
 	const placeholders = getDefaultPaths(nitro);
 	const typesConfig = getTypesConfig(nitro);
@@ -330,22 +331,22 @@ async function generateMainClientTypes(nitro) {
 	if (clientTypesPath) {
 		mkdirSync(dirname(clientTypesPath), { recursive: true });
 		writeFileSync(clientTypesPath, types.types, "utf-8");
-		consola.success(`[nitro-graphql] Generated client types at: ${clientTypesPath}`);
+		if (!options.silent) logger.success(`Generated client types at: ${clientTypesPath}`);
 	}
 	const sdkPath = resolveFilePath(sdkConfig.main, sdkConfig.enabled, true, "{clientGraphql}/default/sdk.ts", placeholders);
 	if (sdkPath) {
 		mkdirSync(dirname(sdkPath), { recursive: true });
 		writeFileSync(sdkPath, types.sdk, "utf-8");
-		consola.success(`[nitro-graphql] Generated SDK at: ${sdkPath}`);
+		if (!options.silent) logger.success(`Generated SDK at: ${sdkPath}`);
 	}
 	generateNuxtOfetchClient(nitro, nitro.graphql.clientDir, "default");
 	const externalServices = nitro.options.graphql?.externalServices || [];
 	if (externalServices.length > 0) generateGraphQLIndexFile(nitro, nitro.graphql.clientDir, externalServices);
 }
-async function generateExternalServicesTypes(nitro) {
+async function generateExternalServicesTypes(nitro, options = {}) {
 	const externalServices = nitro.options.graphql?.externalServices || [];
 	for (const service of externalServices) try {
-		consola.info(`[graphql:${service.name}] Processing external service`);
+		if (!options.silent) consola.info(`[graphql:${service.name}] Processing external service`);
 		await downloadAndSaveSchema(service, nitro.options.buildDir);
 		const schema = await loadExternalSchema(service, nitro.options.buildDir);
 		if (!schema) {
@@ -379,16 +380,16 @@ async function generateExternalServicesTypes(nitro) {
 		if (serviceTypesPath) {
 			mkdirSync(dirname(serviceTypesPath), { recursive: true });
 			writeFileSync(serviceTypesPath, types.types, "utf-8");
-			consola.success(`[graphql:${service.name}] Generated types at: ${serviceTypesPath}`);
+			if (!options.silent) consola.success(`[graphql:${service.name}] Generated types at: ${serviceTypesPath}`);
 		}
 		const serviceSdkPath = resolveFilePath(service.paths?.sdk ?? sdkConfig.external, sdkConfig.enabled, true, "{clientGraphql}/{serviceName}/sdk.ts", placeholders);
 		if (serviceSdkPath) {
 			mkdirSync(dirname(serviceSdkPath), { recursive: true });
 			writeFileSync(serviceSdkPath, types.sdk, "utf-8");
-			consola.success(`[graphql:${service.name}] Generated SDK at: ${serviceSdkPath}`);
+			if (!options.silent) consola.success(`[graphql:${service.name}] Generated SDK at: ${serviceSdkPath}`);
 		}
 		generateExternalOfetchClient(nitro, service, service.endpoint);
-		consola.success(`[graphql:${service.name}] External service types generated successfully`);
+		if (!options.silent) consola.success(`[graphql:${service.name}] External service types generated successfully`);
 	} catch (error) {
 		consola.error(`[graphql:${service.name}] External service generation failed:`, error);
 	}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nitro-graphql",
   "type": "module",
-  "version": "2.0.0-beta.24",
+  "version": "2.0.0-beta.26",
   "description": "GraphQL integration for Nitro",
   "license": "MIT",
   "sideEffects": false,
@@ -59,6 +59,10 @@
     "./vite": {
       "types": "./dist/vite.d.mts",
       "import": "./dist/vite.mjs"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.mts",
+      "import": "./dist/types/index.mjs"
     }
   },
   "module": "./dist/index.mjs",