feat: add support for custom types path configuration and implement E2E tests

Author: productdevbook

src/nitro/codegen.ts

@@ -8,9 +8,10 @@ import type { Nitro } from 'nitro/types'
 import { existsSync, readFileSync } from 'node:fs'
 import { loadFilesSync } from '@graphql-tools/load-files'
 import { mergeTypeDefs } from '@graphql-tools/merge'
+import { makeExecutableSchema } from '@graphql-tools/schema'
 import { printSchemaWithDirectives } from '@graphql-tools/utils'
 import consola from 'consola'
-import { buildSchema, lexicographicSortSchema, parse, print } from 'graphql'
+import { parse, print } from 'graphql'
 import { join, resolve } from 'pathe'
 import {
   downloadAndSaveSchema,
@@ -31,6 +32,7 @@ import { getDefaultPaths, getSdkConfig, getTypesConfig, resolveFilePath, shouldG
 const logger = consola.withTag(LOG_TAG)
 
 // Helper: Build schema with optional federation support
+// Uses @graphql-tools to ensure same graphql instance is used throughout
 async function buildSchemaFromString(source: string, federation: boolean): Promise<GraphQLSchema> {
   if (federation) {
     const buildSubgraph = await loadFederationSupport()
@@ -39,7 +41,9 @@ async function buildSchemaFromString(source: string, federation: boolean): Promi
     }
     return buildSubgraph([{ typeDefs: parse(source) }])
   }
-  return buildSchema(source)
+  // Use makeExecutableSchema from @graphql-tools to ensure same graphql instance
+  // This allows printSchemaWithDirectives to work without "different module" errors
+  return makeExecutableSchema({ typeDefs: source })
 }
 
 /**
@@ -84,15 +88,17 @@ export async function generateServerTypes(
     if (!validateNoDuplicateTypes(validSchemas, strings))
       return
 
-    const merged = mergeTypeDefs([strings.join('\n\n')], { throwOnConflict: true })
+    // mergeTypeDefs with sort: true provides deterministic ordering
+    const merged = mergeTypeDefs([strings.join('\n\n')], { throwOnConflict: true, sort: true })
+    // print(merged) preserves directives from the merged DocumentNode
     const mergedSchemaString = print(merged)
     const federation = nitro.options.graphql?.federation?.enabled === true
     const schema = await buildSchemaFromString(mergedSchemaString, federation)
 
-    // Sort schema for deterministic output
-    const sortedSchema = lexicographicSortSchema(schema)
-    // Get sorted schema string with directives preserved
-    const sortedSchemaString = printSchemaWithDirectives(sortedSchema)
+    // Use printSchemaWithDirectives to preserve custom directives in the output
+    // Note: We skip lexicographicSortSchema because it causes graphql instance mismatch errors
+    // The schema is already sorted by mergeTypeDefs with sort: true
+    const sortedSchemaString = printSchemaWithDirectives(schema)
 
     // Generate types - pass schemaString to avoid graphql instance mismatch
     const result = await generateServerTypesCore({
@@ -223,8 +229,6 @@ async function generateExternalTypes(
         consola.warn(`[${service.name}] Failed to load schema`)
         continue
       }
-      const sortedSchema = lexicographicSortSchema(schema)
-
       const docs = service.documents?.length
         ? await loadGraphQLDocuments(service.documents).catch(() => [])
         : []
@@ -234,7 +238,8 @@ async function generateExternalTypes(
         continue
       }
 
-      const types = await generateExternalClientTypesCore(service as any, sortedSchema, docs)
+      // Use schema directly without lexicographicSortSchema to avoid graphql instance mismatch
+      const types = await generateExternalClientTypesCore(service as any, schema, docs)
       if (types === false)
         continue
 

tests/e2e/custom-types-path.test.ts

@@ -0,0 +1,212 @@
+/**
+ * E2E tests for custom types path configuration
+ *
+ * This test verifies that types files are generated at custom paths
+ * when configured via the `types` option.
+ *
+ * Scenarios tested:
+ * - Custom server types path with {rootDir} placeholder
+ * - Custom client types path with {typesDir} placeholder
+ * - Disabled client types (client: false)
+ * - Default paths when types is true
+ */
+import type { Nitro } from 'nitro/types'
+import { existsSync, readFileSync, rmSync } from 'node:fs'
+import { build, createNitro, prepare } from 'nitro/builder'
+import { join, resolve } from 'pathe'
+import { afterAll, afterEach, beforeAll, describe, expect, it } from 'vitest'
+import graphql from '../../src'
+
+const fixturesDir = resolve(__dirname, '../fixtures')
+const projectDir = resolve(fixturesDir, 'custom-types-path')
+
+// Clean up generated files
+function cleanupGeneratedFiles() {
+  const dirsToClean = [
+    join(projectDir, '.nitro'),
+    join(projectDir, '.output'),
+    join(projectDir, 'generated'),
+    join(projectDir, 'custom-types'),
+  ]
+
+  for (const dir of dirsToClean) {
+    if (existsSync(dir)) {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  }
+}
+
+describe('custom Types Path E2E', () => {
+  // Note: cleanup is done in beforeAll of each describe block, not afterEach
+  // This prevents files from being deleted between tests in the same group
+
+  describe('custom server and client types paths', () => {
+    let nitro: Nitro
+
+    beforeAll(async () => {
+      cleanupGeneratedFiles()
+
+      nitro = await createNitro({
+        rootDir: projectDir,
+        dev: true,
+        modules: [
+          graphql({
+            framework: 'graphql-yoga',
+            types: {
+              enabled: true,
+              server: '{rootDir}/generated/server-types.d.ts',
+              client: '{rootDir}/generated/client-types.d.ts',
+            },
+          }),
+        ],
+      })
+
+      await prepare(nitro)
+      await build(nitro)
+
+      // Generate types
+      const { generateServerTypes, generateClientTypes } = await import('../../src/nitro/codegen')
+      await generateServerTypes(nitro)
+      await generateClientTypes(nitro)
+    }, 60000)
+
+    afterAll(async () => {
+      await nitro?.close()
+    })
+
+    it('should generate server types at custom path', () => {
+      const customServerTypesPath = join(projectDir, 'generated/server-types.d.ts')
+
+      expect(existsSync(customServerTypesPath)).toBe(true)
+
+      const content = readFileSync(customServerTypesPath, 'utf-8')
+      expect(content).toContain('Query')
+      expect(content).toContain('User')
+    })
+
+    it('should generate client types at custom path', () => {
+      const customClientTypesPath = join(projectDir, 'generated/client-types.d.ts')
+
+      expect(existsSync(customClientTypesPath)).toBe(true)
+
+      const content = readFileSync(customClientTypesPath, 'utf-8')
+      expect(content).toContain('GetUser')
+      expect(content).toContain('GetHello')
+    })
+
+    it('should NOT generate types at default paths', () => {
+      const defaultServerPath = join(projectDir, '.nitro/types/nitro-graphql-server.d.ts')
+      const defaultClientPath = join(projectDir, '.nitro/types/nitro-graphql-client.d.ts')
+
+      // Default paths should NOT exist when custom paths are configured
+      expect(existsSync(defaultServerPath)).toBe(false)
+      expect(existsSync(defaultClientPath)).toBe(false)
+    })
+  })
+
+  describe('disabled client types', () => {
+    let nitro: Nitro
+
+    beforeAll(async () => {
+      cleanupGeneratedFiles()
+
+      nitro = await createNitro({
+        rootDir: projectDir,
+        dev: true,
+        modules: [
+          graphql({
+            framework: 'graphql-yoga',
+            types: {
+              enabled: true,
+              server: '{rootDir}/custom-types/server.d.ts',
+              client: false, // Disable client types
+            },
+          }),
+        ],
+      })
+
+      await prepare(nitro)
+      await build(nitro)
+
+      const { generateServerTypes, generateClientTypes } = await import('../../src/nitro/codegen')
+      await generateServerTypes(nitro)
+      await generateClientTypes(nitro)
+    }, 60000)
+
+    afterAll(async () => {
+      await nitro?.close()
+    })
+
+    it('should generate server types when enabled', () => {
+      const serverTypesPath = join(projectDir, 'custom-types/server.d.ts')
+
+      expect(existsSync(serverTypesPath)).toBe(true)
+
+      const content = readFileSync(serverTypesPath, 'utf-8')
+      expect(content).toContain('Query')
+    })
+
+    it('should NOT generate client types when disabled', () => {
+      const defaultClientPath = join(projectDir, '.nitro/types/nitro-graphql-client.d.ts')
+      const customClientPath = join(projectDir, 'custom-types/client.d.ts')
+
+      expect(existsSync(defaultClientPath)).toBe(false)
+      expect(existsSync(customClientPath)).toBe(false)
+    })
+  })
+
+  describe('typesDir placeholder', () => {
+    let nitro: Nitro
+
+    beforeAll(async () => {
+      cleanupGeneratedFiles()
+
+      nitro = await createNitro({
+        rootDir: projectDir,
+        dev: true,
+        modules: [
+          graphql({
+            framework: 'graphql-yoga',
+            types: {
+              enabled: true,
+              server: '{typesDir}/custom-server.d.ts',
+              client: '{typesDir}/custom-client.d.ts',
+            },
+          }),
+        ],
+      })
+
+      await prepare(nitro)
+      await build(nitro)
+
+      const { generateServerTypes, generateClientTypes } = await import('../../src/nitro/codegen')
+      await generateServerTypes(nitro)
+      await generateClientTypes(nitro)
+    }, 60000)
+
+    afterAll(async () => {
+      await nitro?.close()
+    })
+
+    it('should resolve {typesDir} placeholder correctly', () => {
+      // typesDir defaults to {buildDir}/types - buildDir is node_modules/.nitro in test env
+      const serverTypesPath = join(nitro.options.buildDir, 'types/custom-server.d.ts')
+      const clientTypesPath = join(nitro.options.buildDir, 'types/custom-client.d.ts')
+
+      expect(existsSync(serverTypesPath)).toBe(true)
+      expect(existsSync(clientTypesPath)).toBe(true)
+    })
+
+    it('should contain correct type definitions', () => {
+      const serverTypesPath = join(nitro.options.buildDir, 'types/custom-server.d.ts')
+      const clientTypesPath = join(nitro.options.buildDir, 'types/custom-client.d.ts')
+
+      const serverContent = readFileSync(serverTypesPath, 'utf-8')
+      expect(serverContent).toContain('Query')
+      expect(serverContent).toContain('User')
+
+      const clientContent = readFileSync(clientTypesPath, 'utf-8')
+      expect(clientContent).toContain('GetUser')
+    })
+  })
+})

tests/fixtures/custom-types-path/graphql/default/sdk.ts

@@ -0,0 +1,35 @@
+// THIS FILE IS GENERATED, DO NOT EDIT!
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+import type * as Types from '#graphql/client';
+
+import type { ExecutionResult } from 'graphql';
+
+export const GetUserDocument = /*#__PURE__*/ `
+    query GetUser($id: ID!) {
+  user(id: $id) {
+    id
+    name
+    email
+  }
+}
+    `;
+export const GetHelloDocument = /*#__PURE__*/ `
+    query GetHello {
+  hello
+}
+    `;
+export type Requester<C = {}, E = unknown> = <R, V>(doc: string, vars?: V, options?: C) => Promise<ExecutionResult<R, E>> | AsyncIterable<ExecutionResult<R, E>>
+export function getSdk<C, E>(requester: Requester<C, E>) {
+  return {
+    GetUser(variables: Types.GetUserQueryVariables, options?: C): Promise<ExecutionResult<Types.GetUserQuery, E>> {
+      return requester<Types.GetUserQuery, Types.GetUserQueryVariables>(GetUserDocument, variables, options) as Promise<ExecutionResult<Types.GetUserQuery, E>>;
+    },
+    GetHello(variables?: Types.GetHelloQueryVariables, options?: C): Promise<ExecutionResult<Types.GetHelloQuery, E>> {
+      return requester<Types.GetHelloQuery, Types.GetHelloQueryVariables>(GetHelloDocument, variables, options) as Promise<ExecutionResult<Types.GetHelloQuery, E>>;
+    }
+  };
+}
+export type Sdk = ReturnType<typeof getSdk>;

tests/fixtures/custom-types-path/graphql/getUser.graphql

@@ -0,0 +1,11 @@
+query GetUser($id: ID!) {
+  user(id: $id) {
+    id
+    name
+    email
+  }
+}
+
+query GetHello {
+  hello
+}

tests/fixtures/custom-types-path/server/graphql/schema.graphql

@@ -0,0 +1,10 @@
+type Query {
+  hello: String!
+  user(id: ID!): User
+}
+
+type User {
+  id: ID!
+  name: String!
+  email: String!
+}