nitro-graphql 2.0.0-beta.7 → 2.0.0-beta.70

package/dist/nitro/setup/ts-config.mjs

@@ -0,0 +1,69 @@
+import { relativeWithDot } from "../../core/utils/imports.mjs";
+import { getDefaultPaths, getTypesConfig, resolveFilePath } from "../paths.mjs";
+import { dirname, join, resolve } from "pathe";
+
+//#region src/nitro/setup/ts-config.ts
+/**
+* Setup TypeScript path aliases for GraphQL types
+* Called via nitro:config hook to extend tsconfig.json
+*/
+function setupTypeScriptPaths(nitro, types) {
+	const tsconfigDir = dirname(resolve(nitro.options.buildDir, nitro.options.typescript.tsconfigPath ?? "tsconfig.json"));
+	types.tsConfig ||= {};
+	types.tsConfig.compilerOptions ??= {};
+	types.tsConfig.compilerOptions.paths ??= {};
+	types.tsConfig.include = types.tsConfig.include || [];
+	const placeholders = getDefaultPaths(nitro);
+	const typesConfig = getTypesConfig(nitro);
+	setupServerTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig);
+	setupClientTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig);
+	setupSchemaPath(nitro, types, tsconfigDir);
+	setupExternalServicePaths(nitro, types, tsconfigDir, placeholders, typesConfig);
+	types.tsConfig.include.push(relativeWithDot(tsconfigDir, join(placeholders.typesDir, "graphql.d.ts")));
+}
+/**
+* Setup #graphql/server path alias
+*/
+function setupServerTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig) {
+	const serverTypesPath = resolveFilePath(typesConfig.server, typesConfig.enabled, true, "{typesDir}/nitro-graphql-server.d.ts", placeholders);
+	if (serverTypesPath) {
+		types.tsConfig.compilerOptions.paths["#graphql/server"] = [relativeWithDot(tsconfigDir, serverTypesPath)];
+		types.tsConfig.include.push(relativeWithDot(tsconfigDir, serverTypesPath));
+	}
+}
+/**
+* Setup #graphql/client path alias
+*/
+function setupClientTypesPath(nitro, types, tsconfigDir, placeholders, typesConfig) {
+	const clientTypesPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
+	if (clientTypesPath) {
+		types.tsConfig.compilerOptions.paths["#graphql/client"] = [relativeWithDot(tsconfigDir, clientTypesPath)];
+		types.tsConfig.include.push(relativeWithDot(tsconfigDir, clientTypesPath));
+	}
+}
+/**
+* Setup #graphql/schema path alias
+*/
+function setupSchemaPath(nitro, types, tsconfigDir) {
+	types.tsConfig.compilerOptions.paths["#graphql/schema"] = [relativeWithDot(tsconfigDir, join(nitro.graphql.serverDir, "schema.ts"))];
+}
+/**
+* Setup #graphql/client/{serviceName} path aliases for external services
+*/
+function setupExternalServicePaths(nitro, types, tsconfigDir, placeholders, typesConfig) {
+	if (!nitro.options.graphql?.externalServices?.length) return;
+	for (const service of nitro.options.graphql.externalServices) {
+		const servicePlaceholders = {
+			...placeholders,
+			serviceName: service.name
+		};
+		const externalTypesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", servicePlaceholders);
+		if (externalTypesPath) {
+			types.tsConfig.compilerOptions.paths[`#graphql/client/${service.name}`] = [relativeWithDot(tsconfigDir, externalTypesPath)];
+			types.tsConfig.include.push(relativeWithDot(tsconfigDir, externalTypesPath));
+		}
+	}
+}
+
+//#endregion
+export { setupTypeScriptPaths };

package/dist/nitro/setup.d.mts

@@ -0,0 +1,11 @@
+import { resolveSecurityConfig } from "./setup/logging.mjs";
+import { Nitro } from "nitro/types";
+
+//#region src/nitro/setup.d.ts
+/**
+ * Main setup function for nitro-graphql
+ * Coordinates all initialization steps for the module
+ */
+declare function setupNitroGraphQL(nitro: Nitro): Promise<void>;
+//#endregion
+export { resolveSecurityConfig, setupNitroGraphQL };

package/dist/nitro/setup.mjs

@@ -0,0 +1,191 @@
+import { FRAMEWORK_NITRO, FRAMEWORK_NUXT, LOG_TAG } from "../core/constants.mjs";
+import { validateExternalServices } from "../core/validation/external-services.mjs";
+import { getDefaultPaths } from "./paths.mjs";
+import { generateClientTypes, generateServerTypes } from "./codegen.mjs";
+import { DEFAULT_RUNTIME_CONFIG, DEFAULT_TYPESCRIPT_STRICT, DEFAULT_TYPES_CONFIG } from "./config.mjs";
+import { rollupConfig } from "./rollup.mjs";
+import { resolveExtendDirs } from "./setup/extend-loader.mjs";
+import { isServerEnabled, logResolverDiagnostics, performGraphQLScan } from "./setup/scanner.mjs";
+import { getWatchDirectories, setupFileWatcher } from "./setup/file-watcher.mjs";
+import { logStartupInfo, resolveSecurityConfig } from "./setup/logging.mjs";
+import { setupNoExternals, setupRollupChunking, setupRollupExternals } from "./setup/rollup-integration.mjs";
+import { registerRouteHandlers } from "./setup/routes.mjs";
+import { setupTypeScriptPaths } from "./setup/ts-config.mjs";
+import defu from "defu";
+import consola from "consola";
+import { relative, resolve } from "pathe";
+
+//#region src/nitro/setup.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Main setup function for nitro-graphql
+* Coordinates all initialization steps for the module
+*/
+async function setupNitroGraphQL(nitro) {
+	const serverEnabled = isServerEnabled(nitro);
+	initializeConfiguration(nitro, serverEnabled);
+	validateConfiguration(nitro);
+	setupBuildDirectories(nitro);
+	if (serverEnabled) {
+		setupNoExternals(nitro);
+		setupRollupExternals(nitro);
+		setupRollupChunking(nitro);
+	}
+	initializeRuntimeConfig(nitro);
+	const extendDirs = await resolveExtendDirs(nitro);
+	if (nitro.options.dev) setupFileWatching(nitro, serverEnabled, extendDirs);
+	await performGraphQLScan(nitro);
+	if (serverEnabled) setupDevHooks(nitro);
+	if (serverEnabled) await rollupConfig(nitro);
+	await generateTypes(nitro, serverEnabled);
+	setupCloseHooks(nitro, serverEnabled);
+	if (serverEnabled) registerRouteHandlers(nitro);
+	setupTypeScriptConfiguration(nitro);
+	setupNuxtIntegration(nitro);
+	logStartupInfo(nitro, serverEnabled);
+}
+/**
+* Initialize default configuration values
+*/
+function initializeConfiguration(nitro, serverEnabled) {
+	nitro.options.graphql ||= {};
+	nitro.options.graphql.types = defu(nitro.options.graphql.types, DEFAULT_TYPES_CONFIG);
+	if (serverEnabled && !nitro.options.graphql?.framework) logger.warn("No GraphQL framework specified. Please set graphql.framework to \"graphql-yoga\" or \"apollo-server\".");
+	const defaultPaths = getDefaultPaths(nitro);
+	nitro.graphql ||= {
+		buildDir: "",
+		watchDirs: [],
+		clientDir: defaultPaths.clientDir,
+		serverDir: defaultPaths.serverDir,
+		dir: {
+			build: relative(nitro.options.rootDir, nitro.options.buildDir),
+			client: "graphql",
+			server: "server"
+		},
+		directiveSchemas: null,
+		extendConfigs: [],
+		extendSchemas: []
+	};
+	nitro.scanSchemas ||= [];
+	nitro.scanResolvers ||= [];
+	nitro.scanDirectives ||= [];
+	nitro.scanDocuments ||= [];
+	if (nitro.options.graphql?.subscriptions?.enabled) nitro.options.features = {
+		...nitro.options.features,
+		websocket: true
+	};
+}
+/**
+* Validate external services configuration
+*/
+function validateConfiguration(nitro) {
+	if (nitro.options.graphql?.externalServices?.length) {
+		const validationErrors = validateExternalServices(nitro.options.graphql.externalServices);
+		if (validationErrors.length > 0) {
+			logger.error("External services configuration errors:");
+			for (const error of validationErrors) logger.error(`  - ${error}`);
+			throw new Error("Invalid external services configuration");
+		}
+		logger.info(`Configured ${nitro.options.graphql.externalServices.length} external GraphQL services`);
+	}
+	if (nitro.options.graphql?.federation?.enabled) logger.info(`Apollo Federation enabled for service: ${nitro.options.graphql.federation.serviceName || "unnamed"}`);
+}
+/**
+* Setup build directories
+*/
+function setupBuildDirectories(nitro) {
+	const graphqlBuildDir = resolve(nitro.options.rootDir, ".graphql");
+	nitro.graphql.buildDir = graphqlBuildDir;
+	switch (nitro.options.framework.name) {
+		case FRAMEWORK_NUXT:
+			nitro.graphql.dir.client = relative(nitro.options.rootDir, nitro.graphql.clientDir);
+			nitro.graphql.dir.server = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+			break;
+		case FRAMEWORK_NITRO:
+			nitro.graphql.dir.client = relative(nitro.options.rootDir, nitro.graphql.clientDir);
+			nitro.graphql.dir.server = relative(nitro.options.rootDir, nitro.graphql.serverDir);
+			break;
+		default: break;
+	}
+}
+/**
+* Initialize runtime configuration
+*/
+function initializeRuntimeConfig(nitro) {
+	const securityConfig = resolveSecurityConfig(nitro.options.graphql?.security);
+	nitro.options.runtimeConfig.graphql = defu(nitro.options.runtimeConfig.graphql || {}, {
+		...DEFAULT_RUNTIME_CONFIG,
+		security: securityConfig
+	});
+}
+/**
+* Setup file watching for development mode
+*/
+function setupFileWatching(nitro, serverEnabled, extendDirs = []) {
+	const watchDirs = serverEnabled ? getWatchDirectories(nitro, extendDirs) : [nitro.graphql.clientDir].filter(Boolean);
+	nitro.graphql.watchDirs = watchDirs;
+	const watcher = setupFileWatcher(nitro, watchDirs);
+	nitro.hooks.hook("close", () => {
+		watcher.close();
+	});
+}
+/**
+* Setup dev mode hooks for rescanning files
+*/
+function setupDevHooks(nitro) {
+	let hasShownInitialLogs = false;
+	let lastDevStart = 0;
+	const DEBOUNCE_MS = 500;
+	nitro.hooks.hook("dev:start", async () => {
+		const now = Date.now();
+		if (now - lastDevStart < DEBOUNCE_MS) return;
+		lastDevStart = now;
+		await performGraphQLScan(nitro, {
+			isRescan: true,
+			silent: true
+		});
+		if (nitro.options.dev && !hasShownInitialLogs) {
+			hasShownInitialLogs = true;
+			logResolverDiagnostics(nitro);
+		}
+	});
+}
+/**
+* Generate server and client types
+*/
+async function generateTypes(nitro, serverEnabled) {
+	if (serverEnabled) {
+		await generateServerTypes(nitro);
+		await generateClientTypes(nitro, { isInitial: true });
+	} else await generateClientTypes(nitro, { isInitial: true });
+}
+/**
+* Setup close hooks for final type generation
+*/
+function setupCloseHooks(nitro, serverEnabled) {
+	nitro.hooks.hook("close", async () => {
+		if (serverEnabled) await generateServerTypes(nitro, { silent: true });
+		await generateClientTypes(nitro, { silent: true });
+	});
+}
+/**
+* Setup TypeScript configuration and path aliases
+*/
+function setupTypeScriptConfiguration(nitro) {
+	nitro.options.typescript.strict = DEFAULT_TYPESCRIPT_STRICT;
+	nitro.hooks.hook("types:extend", (types) => {
+		setupTypeScriptPaths(nitro, types);
+	});
+}
+/**
+* Setup Nuxt-specific integration
+*/
+function setupNuxtIntegration(nitro) {
+	if (nitro.options.framework?.name === FRAMEWORK_NUXT && nitro.options.graphql?.externalServices?.length) nitro.hooks.hook("build:before", () => {
+		const nuxtOptions = nitro._nuxt?.options;
+		if (nuxtOptions) nuxtOptions.nitroGraphqlExternalServices = nitro.options.graphql?.externalServices || [];
+	});
+}
+
+//#endregion
+export { resolveSecurityConfig, setupNitroGraphQL };