nitro-graphql 2.0.0-beta.30 → 2.0.0-beta.32

package/dist/setup/rollup-integration.mjs

@@ -0,0 +1,90 @@
+import { CHUNK_NAME_RESOLVERS, CHUNK_NAME_SCHEMAS, CHUNK_PATH_GRAPHQL, CHUNK_PATH_UNKNOWN, GRAPHQL_EXTENSIONS, RESOLVER_EXTENSIONS } from "../constants.mjs";
+
+//#region src/setup/rollup-integration.ts
+/**
+* Setup Rollup/Rolldown chunking configuration for GraphQL files
+* Creates separate chunks for schemas and resolvers to optimize bundle size
+*/
+function setupRollupChunking(nitro) {
+	nitro.hooks.hook("rollup:before", (_, rollupConfig) => {
+		const manualChunks = rollupConfig.output?.manualChunks;
+		const chunkFiles = rollupConfig.output?.chunkFileNames;
+		if (!rollupConfig.output.inlineDynamicImports) {
+			rollupConfig.output.manualChunks = (id, _meta) => {
+				if (isGraphQLFile(id)) return getSchemaChunkName(id);
+				if (isResolverFile(id)) return getResolverChunkName(id);
+				if (typeof manualChunks === "function") return manualChunks(id, meta);
+			};
+			rollupConfig.output.advancedChunks = {
+				groups: [{
+					name: CHUNK_NAME_SCHEMAS,
+					test: /* @__PURE__ */ new RegExp(`\\.(${GRAPHQL_EXTENSIONS.map((e) => e.slice(1)).join("|")})$`)
+				}, {
+					name: CHUNK_NAME_RESOLVERS,
+					test: /\.resolver\.(ts|js)$/
+				}],
+				minSize: 0,
+				minShareCount: 1
+			};
+		}
+		rollupConfig.output.chunkFileNames = (chunkInfo) => {
+			if (chunkInfo.moduleIds && chunkInfo.moduleIds.some((id) => isGraphQLFile(id) || isResolverFile(id))) return CHUNK_PATH_GRAPHQL;
+			if (typeof chunkFiles === "function") return chunkFiles(chunkInfo);
+			return CHUNK_PATH_UNKNOWN;
+		};
+	});
+}
+/**
+* Check if a file is a GraphQL schema file
+*/
+function isGraphQLFile(id) {
+	return GRAPHQL_EXTENSIONS.some((ext) => id.endsWith(ext));
+}
+/**
+* Check if a file is a resolver file
+*/
+function isResolverFile(id) {
+	return RESOLVER_EXTENSIONS.some((ext) => id.endsWith(ext));
+}
+/**
+* Get chunk name for GraphQL schema files
+* All schemas are bundled into a single chunk since GraphQL server
+* merges them at runtime anyway - no benefit from separate chunks
+*/
+function getSchemaChunkName(_id) {
+	return CHUNK_NAME_SCHEMAS;
+}
+/**
+* Get chunk name for resolver files
+* All resolvers are bundled into a single chunk since GraphQL server
+* requires all resolvers to be registered at startup - no runtime lazy loading
+*/
+function getResolverChunkName(_id) {
+	return CHUNK_NAME_RESOLVERS;
+}
+/**
+* Configure external dependencies for Rollup
+* Marks codegen and federation packages as external
+*/
+function setupRollupExternals(nitro) {
+	nitro.hooks.hook("rollup:before", (_, rollupConfig) => {
+		rollupConfig.external = rollupConfig.external || [];
+		const allExternals = [...["oxc-parser", "@oxc-parser"]];
+		if (!nitro.options.graphql?.federation?.enabled) allExternals.push(...[
+			"@apollo/subgraph",
+			"@apollo/federation-internals",
+			"@apollo/cache-control-types"
+		]);
+		if (Array.isArray(rollupConfig.external)) rollupConfig.external.push(...allExternals);
+		else if (typeof rollupConfig.external === "function") {
+			const originalExternal = rollupConfig.external;
+			rollupConfig.external = (id, parent, isResolved) => {
+				if (allExternals.some((external) => id.includes(external))) return true;
+				return originalExternal(id, parent, isResolved);
+			};
+		}
+	});
+}
+
+//#endregion
+export { setupRollupChunking, setupRollupExternals };

package/dist/setup/scaffold-generator.mjs

@@ -0,0 +1,109 @@
+import { FILE_CONFIG_TS, FILE_CONTEXT_DTS, FILE_CONTEXT_TS, FILE_GRAPHQL_CONFIG, FILE_SCHEMA_TS, LOG_TAG } from "../constants.mjs";
+import { relativeWithDot } from "../utils/index.mjs";
+import { writeFileIfNotExists } from "../utils/file-generator.mjs";
+import { getDefaultPaths, getScaffoldConfig, resolveFilePath, shouldGenerateScaffold } from "../utils/path-resolver.mjs";
+import consola from "consola";
+import { join, resolve } from "pathe";
+import { existsSync, mkdirSync } from "node:fs";
+
+//#region src/setup/scaffold-generator.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Generate all scaffold files based on configuration
+* Can be disabled via: scaffold: false or scaffold.enabled: false
+*/
+function generateScaffoldFiles(nitro) {
+	if (!shouldGenerateScaffold(nitro)) {
+		logger.info("Scaffold file generation is disabled (library mode)");
+		return;
+	}
+	const placeholders = getDefaultPaths(nitro);
+	const scaffoldConfig = getScaffoldConfig(nitro);
+	generateGraphQLConfig(nitro, scaffoldConfig, placeholders);
+	generateServerScaffoldFiles(nitro, scaffoldConfig, placeholders);
+	checkOldContextFile(nitro);
+}
+/**
+* Generate graphql.config.ts for IDE tooling support
+*/
+function generateGraphQLConfig(nitro, scaffoldConfig, placeholders) {
+	const graphqlConfigPath = resolveFilePath(scaffoldConfig.graphqlConfig, scaffoldConfig.enabled, true, FILE_GRAPHQL_CONFIG, placeholders);
+	if (!graphqlConfigPath) return;
+	writeFileIfNotExists(graphqlConfigPath, `import type { IGraphQLConfig } from 'graphql-config'
+
+export default <IGraphQLConfig> {
+    projects: {
+      default: {
+        schema: [
+          '${relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.buildDir, "schema.graphql"))}',
+        ],
+        documents: [
+          '${relativeWithDot(nitro.options.rootDir, resolve(nitro.graphql.clientDir, "**/*.{graphql,js,ts,jsx,tsx}"))}',
+        ],
+      },
+    },
+}`, FILE_GRAPHQL_CONFIG);
+}
+/**
+* Generate server-side scaffold files (schema.ts, config.ts, context.d.ts)
+*/
+function generateServerScaffoldFiles(nitro, scaffoldConfig, placeholders) {
+	const serverSchemaPath = resolveFilePath(scaffoldConfig.serverSchema, scaffoldConfig.enabled, true, "{serverGraphql}/schema.ts", placeholders);
+	const serverConfigPath = resolveFilePath(scaffoldConfig.serverConfig, scaffoldConfig.enabled, true, "{serverGraphql}/config.ts", placeholders);
+	const serverContextPath = resolveFilePath(scaffoldConfig.serverContext, scaffoldConfig.enabled, true, "{serverGraphql}/context.d.ts", placeholders);
+	if (serverSchemaPath || serverConfigPath || serverContextPath) {
+		if (!existsSync(nitro.graphql.serverDir)) mkdirSync(nitro.graphql.serverDir, { recursive: true });
+	}
+	if (serverSchemaPath) writeFileIfNotExists(serverSchemaPath, `export default defineSchema({
+
+})
+`, `server ${FILE_SCHEMA_TS}`);
+	if (serverConfigPath) writeFileIfNotExists(serverConfigPath, `// Example GraphQL config file please change it to your needs
+// import * as tables from '../drizzle/schema/index'
+// import { useDatabase } from '../utils/useDb'
+import { defineGraphQLConfig } from 'nitro-graphql/define'
+
+export default defineGraphQLConfig({
+// graphql-yoga example config
+// context: () => {
+//   return {
+//     context: {
+//       useDatabase,
+//       tables,
+//     },
+//   }
+// },
+})
+`, `server ${FILE_CONFIG_TS}`);
+	if (serverContextPath) writeFileIfNotExists(serverContextPath, `// Example context definition - please change it to your needs
+// import type { Database } from '../utils/useDb'
+
+declare module 'nitro/h3' {
+  interface H3EventContext {
+    // Add your custom context properties here
+    // useDatabase: () => Database
+    // tables: typeof import('../drizzle/schema')
+    // auth?: {
+    //   user?: {
+    //     id: string
+    //     role: 'admin' | 'user'
+    //   }
+    // }
+  }
+}
+
+export {}
+`, `server ${FILE_CONTEXT_DTS}`);
+}
+/**
+* Check for old context.ts file and warn users to migrate to context.d.ts
+*/
+function checkOldContextFile(nitro) {
+	if (existsSync(join(nitro.graphql.serverDir, FILE_CONTEXT_TS))) {
+		logger.warn(`Found ${FILE_CONTEXT_TS} file. Please rename it to ${FILE_CONTEXT_DTS} for type-only definitions.`);
+		logger.info(`The context file should now be ${FILE_CONTEXT_DTS} instead of ${FILE_CONTEXT_TS}`);
+	}
+}
+
+//#endregion
+export { generateScaffoldFiles };

package/dist/setup/ts-config.mjs

@@ -0,0 +1,69 @@
+import { relativeWithDot } from "../utils/index.mjs";
+import { getDefaultPaths, getTypesConfig, resolveFilePath } from "../utils/path-resolver.mjs";
+import { dirname, join, resolve } from "pathe";
+
+//#region src/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));
+	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/setup.d.mts

@@ -3,8 +3,8 @@ import { Nitro } from "nitro/types";
 //#region src/setup.d.ts
 
 /**
- * Shared setup logic for nitro-graphql module
- * Used by both the direct Nitro module export and the Vite plugin's nitro: hook
+ * Main setup function for nitro-graphql
+ * Coordinates all initialization steps for the module
  */
 declare function setupNitroGraphQL(nitro: Nitro): Promise<void>;
 //#endregion