Add support for custom names for root types

hayes · hayes · commit 456da16063e0 · 2025-02-19T17:16:20.000-08:00
diff --git a/.changeset/great-rules-try.md b/.changeset/great-rules-try.md
@@ -0,0 +1,8 @@
+---
+"@pothos/plugin-federation": minor
+"@pothos/plugin-sub-graph": minor
+"@pothos/converter": minor
+"@pothos/core": minor
+---
+
+Add support for custom names on Root types
diff --git a/packages/converter/src/index.ts b/packages/converter/src/index.ts
@@ -167,13 +167,13 @@ export default class PothosConverter {
 
       if (type instanceof GraphQLObjectType) {
         switch (type.name) {
-          case 'Query':
+          case this.schema.getQueryType()?.name ?? 'Query':
             this.queryType(type);
             break;
-          case 'Mutation':
+          case this.schema.getMutationType()?.name ?? 'Mutation':
             this.mutationType(type);
             break;
-          case 'Subscription':
+          case this.schema.getSubscriptionType()?.name ?? 'Subscription':
             this.subscriptionType(type);
             break;
           default:
@@ -204,6 +204,11 @@ export default class PothosConverter {
     this.sourcefile.addStatements((writer) => {
       writer.writeLine('builder.queryType({');
       writer.indent(() => {
+        if (type.name !== 'Query') {
+          writer.write('name:');
+          writer.quote(type.name);
+          writer.writeLine(',');
+        }
         this.writeDescription(writer, type);
         this.writeObjectShape(writer, type);
       });
@@ -215,6 +220,11 @@ export default class PothosConverter {
     this.sourcefile.addStatements((writer) => {
       writer.writeLine('builder.mutationType({');
       writer.indent(() => {
+        if (type.name !== 'Mutation') {
+          writer.write('name:');
+          writer.quote(type.name);
+          writer.writeLine(',');
+        }
         this.writeDescription(writer, type);
         this.writeObjectShape(writer, type);
       });
@@ -226,6 +236,11 @@ export default class PothosConverter {
     this.sourcefile.addStatements((writer) => {
       writer.writeLine('builder.subscriptionType({');
       writer.indent(() => {
+        if (type.name !== 'Subscription') {
+          writer.write('name:');
+          writer.quote(type.name);
+          writer.writeLine(',');
+        }
         this.writeDescription(writer, type);
         this.writeObjectShape(writer, type);
       });
@@ -442,7 +457,7 @@ export default class PothosConverter {
             `resolve: (parent, args, context, info) => { throw new Error('Not implemented') },`,
           );
 
-          if (type.name === 'Subscription') {
+          if (type.name === (this.schema.getSubscriptionType()?.name ?? 'Subscription')) {
             writer.writeLine(
               `subscribe: (parent, args, context, info) => { throw new Error('Not implemented') },`,
             );
diff --git a/packages/core/src/builder.ts b/packages/core/src/builder.ts
@@ -230,15 +230,19 @@ export class SchemaBuilder<Types extends SchemaTypes> {
   ): QueryRef<Types> {
     const [options = {}, fields] = args;
 
-    const ref = new QueryRef<Types>('Query', {
+    const ref = new QueryRef<Types>(options.name ?? 'Query', {
       kind: 'Query',
       graphqlKind: 'Object',
-      name: 'Query',
+      name: options.name ?? 'Query',
       description: options.description,
       pothosOptions: options as unknown as PothosSchemaTypes.QueryTypeOptions,
       extensions: options.extensions,
     });
 
+    if (ref.name !== 'Query') {
+      this.configStore.associateParamWithRef('Query', ref);
+    }
+
     this.configStore.addTypeRef(ref);
 
     if (fields) {
@@ -270,17 +274,21 @@ export class SchemaBuilder<Types extends SchemaTypes> {
   ) {
     const [options = {}, fields] = args;
 
-    const ref = new MutationRef<Types>('Mutation', {
+    const ref = new MutationRef<Types>(options.name ?? 'Mutation', {
       kind: 'Mutation',
       graphqlKind: 'Object',
-      name: 'Mutation',
+      name: options.name ?? 'Mutation',
       description: options.description,
       pothosOptions: options as unknown as PothosSchemaTypes.MutationTypeOptions,
       extensions: options.extensions,
     });
 
     this.configStore.addTypeRef(ref);
 
+    if (ref.name !== 'Mutation') {
+      this.configStore.associateParamWithRef('Mutation', ref);
+    }
+
     if (fields) {
       this.configStore.addFields('Mutation', () => fields(new MutationFieldBuilder(this)));
     }
@@ -313,17 +321,21 @@ export class SchemaBuilder<Types extends SchemaTypes> {
   ) {
     const [options = {}, fields] = args;
 
-    const ref = new SubscriptionRef<Types>('Subscription', {
+    const ref = new SubscriptionRef<Types>(options.name ?? 'Subscription', {
       kind: 'Subscription',
       graphqlKind: 'Object',
-      name: 'Subscription',
+      name: options.name ?? 'Subscription',
       description: options.description,
       pothosOptions: options as unknown as PothosSchemaTypes.SubscriptionTypeOptions,
       extensions: options.extensions,
     });
 
     this.configStore.addTypeRef(ref);
 
+    if (ref.name !== 'Subscription') {
+      this.configStore.associateParamWithRef('Subscription', ref);
+    }
+
     if (fields) {
       this.configStore.addFields('Subscription', () => fields(new SubscriptionFieldBuilder(this)));
     }
@@ -671,10 +683,20 @@ export class SchemaBuilder<Types extends SchemaTypes> {
 
     const builtTypes = [...buildCache.types.values()];
 
+    const queryName = this.configStore.hasConfig('Query')
+      ? this.configStore.getTypeConfig('Query').name
+      : 'Query';
+    const mutationName = this.configStore.hasConfig('Mutation')
+      ? this.configStore.getTypeConfig('Mutation').name
+      : 'Mutation';
+    const subscriptionName = this.configStore.hasConfig('Subscription')
+      ? this.configStore.getTypeConfig('Subscription').name
+      : 'Subscription';
+
     const schema = new GraphQLSchema({
-      query: buildCache.types.get('Query') as GraphQLObjectType | undefined,
-      mutation: buildCache.types.get('Mutation') as GraphQLObjectType | undefined,
-      subscription: buildCache.types.get('Subscription') as GraphQLObjectType | undefined,
+      query: buildCache.types.get(queryName) as GraphQLObjectType | undefined,
+      mutation: buildCache.types.get(mutationName) as GraphQLObjectType | undefined,
+      subscription: buildCache.types.get(subscriptionName) as GraphQLObjectType | undefined,
       extensions: extensions ?? {},
       directives: directives as GraphQLDirective[],
       types: builtTypes,
diff --git a/packages/core/src/types/global/type-options.ts b/packages/core/src/types/global/type-options.ts
@@ -49,7 +49,9 @@ declare global {
         | (Interfaces & ValidateInterfaces<Shape, Types, Interfaces[number]>[]);
     }
     export interface RootTypeOptions<Types extends SchemaTypes, Type extends RootName>
-      extends BaseTypeOptions<Types> {}
+      extends BaseTypeOptions<Types> {
+      name?: string;
+    }
 
     export interface QueryTypeOptions<Types extends SchemaTypes = SchemaTypes>
       extends RootTypeOptions<Types, 'Query'> {
diff --git a/packages/core/tests/custom-roots.test.ts b/packages/core/tests/custom-roots.test.ts
@@ -0,0 +1,105 @@
+import { execute, lexicographicSortSchema, printSchema, subscribe } from 'graphql';
+import gql from 'graphql-tag';
+import { schema } from './examples/custom-root-names';
+
+describe('custom-root-names example', () => {
+  it('generates expected schema', () => {
+    expect(printSchema(lexicographicSortSchema(schema))).toMatchInlineSnapshot(`
+      "schema {
+        query: CustomQuery
+        mutation: CustomMutation
+        subscription: CustomSubscription
+      }
+
+      type CustomMutation {
+        hello: String
+      }
+
+      type CustomQuery {
+        hello: String
+      }
+
+      type CustomSubscription {
+        hello: Int
+      }"
+    `);
+  });
+
+  it('executes queries', async () => {
+    const result = await execute({
+      schema,
+      document: gql`
+      query {
+        hello
+        __typename
+      }
+    `,
+    });
+
+    expect(result.data).toMatchInlineSnapshot(`
+      {
+        "__typename": "CustomQuery",
+        "hello": "world",
+      }
+    `);
+  });
+
+  it('executes mutations', async () => {
+    const result = await execute({
+      schema,
+      document: gql`
+        mutation {
+          hello
+          __typename
+        }
+      `,
+    });
+
+    expect(result.data).toMatchInlineSnapshot(`
+      {
+        "__typename": "CustomMutation",
+        "hello": "world",
+      }
+    `);
+  });
+
+  it('executes subscriptions', async () => {
+    const result = await subscribe({
+      schema,
+      document: gql`
+        subscription {
+          hello
+          __typename
+        }
+      `,
+    });
+
+    const results = [];
+    for await (const value of result as AsyncIterable<{ data: { hello: number } }>) {
+      results.push(value);
+    }
+
+    expect(results).toMatchInlineSnapshot(`
+      [
+        {
+          "data": {
+            "__typename": "CustomSubscription",
+            "hello": 0,
+          },
+        },
+        {
+          "data": {
+            "__typename": "CustomSubscription",
+            "hello": 1,
+          },
+        },
+        {
+          "data": {
+            "__typename": "CustomSubscription",
+            "hello": 2,
+          },
+        },
+      ]
+    `);
+  });
+});
diff --git a/packages/core/tests/examples/custom-root-names.ts b/packages/core/tests/examples/custom-root-names.ts
@@ -0,0 +1,38 @@
+import SchemaBuilder from '../../src';
+
+const builder = new SchemaBuilder<{}>({});
+
+builder.queryType({
+  name: 'CustomQuery',
+  fields: (t) => ({
+    hello: t.string({
+      resolve: () => 'world',
+    }),
+  }),
+});
+
+builder.mutationType({
+  name: 'CustomMutation',
+  fields: (t) => ({
+    hello: t.string({
+      resolve: () => 'world',
+    }),
+  }),
+});
+
+builder.subscriptionType({
+  name: 'CustomSubscription',
+  fields: (t) => ({
+    hello: t.int({
+      // biome-ignore lint/suspicious/useAwait: <explanation>
+      subscribe: async function* () {
+        for (let i = 0; i < 3; i++) {
+          yield i;
+        }
+      },
+      resolve: (i) => i,
+    }),
+  }),
+});
+
+export const schema = builder.toSchema();
diff --git a/packages/plugin-federation/src/schema-builder.ts b/packages/plugin-federation/src/schema-builder.ts
@@ -110,7 +110,7 @@ schemaBuilderProto.toSubGraphSchema = function toSubGraphSchema(
       ]),
     },
   });
-  const queryType = schema.getType('Query') as GraphQLObjectType | undefined;
+  const queryType = schema.getQueryType();
   const types = schema.getTypeMap();
 
   queryType?.toConfig();
@@ -127,7 +127,7 @@ schemaBuilderProto.toSubGraphSchema = function toSubGraphSchema(
   });
 
   const newQuery = new GraphQLObjectType({
-    name: 'Query',
+    name: queryType?.name ?? 'Query',
     description: queryType?.description,
     astNode: queryType?.astNode,
     extensions: queryType?.extensions,
@@ -148,8 +148,8 @@ schemaBuilderProto.toSubGraphSchema = function toSubGraphSchema(
 
   const subGraphSchema = new GraphQLSchema({
     query: newQuery,
-    mutation: schema.getType('Mutation') as GraphQLObjectType,
-    subscription: schema.getType('Subscription') as GraphQLObjectType,
+    mutation: schema.getMutationType(),
+    subscription: schema.getSubscriptionType(),
     extensions: schema.extensions,
     directives: schema.getDirectives(),
     extensionASTNodes: schema.extensionASTNodes,
diff --git a/packages/plugin-sub-graph/src/index.ts b/packages/plugin-sub-graph/src/index.ts
@@ -85,9 +85,11 @@ export class PothosSubGraphPlugin<Types extends SchemaTypes> extends BasePlugin<
       extensions: config.extensions,
       extensionASTNodes: config.extensionASTNodes,
       assumeValid: false,
-      query: newTypes.get('Query') as GraphQLObjectType,
-      mutation: newTypes.get('Mutation') as GraphQLObjectType,
-      subscription: newTypes.get('Subscription') as GraphQLObjectType,
+      query: newTypes.get(schema.getQueryType()?.name ?? 'Query') as GraphQLObjectType,
+      mutation: newTypes.get(schema.getMutationType()?.name ?? 'Mutation') as GraphQLObjectType,
+      subscription: newTypes.get(
+        schema.getSubscriptionType()?.name ?? 'Subscription',
+      ) as GraphQLObjectType,
       // Explicitly include types that implement an interface that can be resolved in the subGraph
       types: [...newTypes.values()].filter(
         (type) =>
