feat(graphql): Add registerIn option for module-scoped type filtering

Add the ability to associate GraphQL types with specific NestJS modules
using the new `registerIn` option. This enables type filtering when
generating schemas for specific modules via the `include` option.

## Motivation
When building multiple GraphQL endpoints with different schemas,
developers need a way to control which types appear in each schema.
Previously, only resolvers could be filtered by module - types were
always included globally.

## Changes
- Add `registerIn` option to decorators:
  - @ObjectType, @inputType, @InterfaceType, @ArgsType
  - registerEnumType(), createUnionType()
- Add `RegisterInOption` type (Function | (() => Function))
- Add module filtering logic in TypeMetadataStorage
- Add TypeDefinitionsStorage.clear() for multi-schema generation
- Connect GqlModuleOptions.include to type filtering

## Behavior
- Types without `registerIn`: Included in all schemas
- Types with `registerIn`: Included only when module is in `include` list

## Example
```typescript
@ObjectType({ registerIn: () => UsersModule })
class User { ... }
```

## Notes
I followed @kamilmysliwiec's suggestion from #1432 (comment)
and took over #1999 since it seems no progress recently.
If you suggest any other solutions please let me know.

## Fixes
#1999, #14759

Author: joe-re

packages/graphql/lib/decorators/args-type.decorator.ts

@@ -1,18 +1,47 @@
 import { ClassType } from '../enums/class-type.enum';
+import { RegisterInOption } from '../schema-builder/metadata';
 import { LazyMetadataStorage } from '../schema-builder/storages/lazy-metadata.storage';
 import { TypeMetadataStorage } from '../schema-builder/storages/type-metadata.storage';
 import { addClassTypeMetadata } from '../utils/add-class-type-metadata.util';
 
+/**
+ * Interface defining options that can be passed to `@ArgsType()` decorator.
+ *
+ * @publicApi
+ */
+export interface ArgsTypeOptions {
+  /**
+   * NestJS module that this type belongs to.
+   * When specified, this type will only be included in GraphQL schemas
+   * that include this module via the `include` option.
+   * @see RegisterInOption for details
+   */
+  registerIn?: RegisterInOption;
+}
+
+/**
+ * Decorator that marks a class as a resolver arguments type.
+ *
+ * @publicApi
+ */
+export function ArgsType(): ClassDecorator;
+/**
+ * Decorator that marks a class as a resolver arguments type.
+ *
+ * @publicApi
+ */
+export function ArgsType(options: ArgsTypeOptions): ClassDecorator;
 /**
  * Decorator that marks a class as a resolver arguments type.
  *
  * @publicApi
  */
-export function ArgsType(): ClassDecorator {
+export function ArgsType(options?: ArgsTypeOptions): ClassDecorator {
   return (target: Function) => {
     const metadata = {
       name: target.name,
       target,
+      registerIn: options?.registerIn,
     };
     LazyMetadataStorage.store(() =>
       TypeMetadataStorage.addArgsMetadata(metadata),

packages/graphql/lib/decorators/input-type.decorator.ts

@@ -7,6 +7,7 @@
 
 import { isString } from '@nestjs/common/utils/shared.utils';
 import { ClassType } from '../enums/class-type.enum';
+import { RegisterInOption } from '../schema-builder/metadata';
 import { LazyMetadataStorage } from '../schema-builder/storages/lazy-metadata.storage';
 import { TypeMetadataStorage } from '../schema-builder/storages/type-metadata.storage';
 import { addClassTypeMetadata } from '../utils/add-class-type-metadata.util';
@@ -30,6 +31,13 @@ export interface InputTypeOptions {
    * More info about '@oneOf' types in the [GraphQL spec](https://spec.graphql.org/September2025/#sec-OneOf-Input-Objects).
    */
   isOneOf?: boolean;
+  /**
+   * NestJS module that this type belongs to.
+   * When specified, this type will only be included in GraphQL schemas
+   * that include this module via the `include` option.
+   * @see RegisterInOption for details
+   */
+  registerIn?: RegisterInOption;
 }
 
 /**
@@ -73,6 +81,7 @@ export function InputType(
       description: options.description,
       isAbstract: options.isAbstract,
       isOneOf: options.isOneOf,
+      registerIn: options.registerIn,
     };
     LazyMetadataStorage.store(() =>
       TypeMetadataStorage.addInputTypeMetadata(metadata),

packages/graphql/lib/decorators/interface-type.decorator.ts

@@ -8,6 +8,7 @@
 import { isString } from '@nestjs/common/utils/shared.utils';
 import { ClassType } from '../enums/class-type.enum';
 import { ResolveTypeFn } from '../interfaces';
+import { RegisterInOption } from '../schema-builder/metadata';
 import { LazyMetadataStorage } from '../schema-builder/storages/lazy-metadata.storage';
 import { TypeMetadataStorage } from '../schema-builder/storages/type-metadata.storage';
 import { addClassTypeMetadata } from '../utils/add-class-type-metadata.util';
@@ -34,6 +35,13 @@ export interface InterfaceTypeOptions {
    * Interfaces implemented by this interface.
    */
   implements?: Function | Function[] | (() => Function | Function[]);
+  /**
+   * NestJS module that this type belongs to.
+   * When specified, this type will only be included in GraphQL schemas
+   * that include this module via the `include` option.
+   * @see RegisterInOption for details
+   */
+  registerIn?: RegisterInOption;
 }
 
 /**
@@ -71,6 +79,7 @@ export function InterfaceType(
         target,
         ...options,
         interfaces: options.implements,
+        registerIn: options.registerIn,
       };
       TypeMetadataStorage.addInterfaceMetadata(metadata);
     };

packages/graphql/lib/decorators/object-type.decorator.ts

@@ -7,6 +7,7 @@
 
 import { isString } from '@nestjs/common/utils/shared.utils';
 import { ClassType } from '../enums/class-type.enum';
+import { RegisterInOption } from '../schema-builder/metadata';
 import { LazyMetadataStorage } from '../schema-builder/storages/lazy-metadata.storage';
 import { TypeMetadataStorage } from '../schema-builder/storages/type-metadata.storage';
 import { addClassTypeMetadata } from '../utils/add-class-type-metadata.util';
@@ -34,6 +35,13 @@ export interface ObjectTypeOptions {
    * Also works on classes marked with `isAbstract: true`.
    */
   inheritDescription?: boolean;
+  /**
+   * NestJS module that this type belongs to.
+   * When specified, this type will only be included in GraphQL schemas
+   * that include this module via the `include` option.
+   * @see RegisterInOption for details
+   */
+  registerIn?: RegisterInOption;
 }
 
 /**
@@ -85,6 +93,7 @@ export function ObjectType(
         interfaces: options.implements,
         isAbstract: options.isAbstract,
         inheritDescription: options.inheritDescription,
+        registerIn: options.registerIn,
       });
 
     // This function must be called eagerly to allow resolvers

packages/graphql/lib/graphql-schema.builder.ts

@@ -43,6 +43,8 @@ export class GraphQLSchemaBuilder {
                 ) ?? true,
             ),
           ],
+          // Pass include modules for type filtering in Code First approach
+          includeModules: options.include,
         },
         options.sortSchema,
         options.transformAutoSchemaFile && options.transformSchema,

packages/graphql/lib/schema-builder/graphql-schema.factory.ts

@@ -23,6 +23,15 @@ import { LazyMetadataStorage } from './storages/lazy-metadata.storage';
 import { TypeMetadataStorage } from './storages/type-metadata.storage';
 import { TypeDefinitionsGenerator } from './type-definitions.generator';
 
+/**
+ * Internal options interface that extends BuildSchemaOptions with includeModules.
+ * This is used internally by GraphQLSchemaBuilder to pass module filtering options.
+ * @internal
+ */
+interface InternalBuildSchemaOptions extends BuildSchemaOptions {
+  includeModules?: Function[];
+}
+
 @Injectable()
 export class GraphQLSchemaFactory {
   private readonly logger = new Logger(GraphQLSchemaFactory.name);
@@ -63,7 +72,12 @@ export class GraphQLSchemaFactory {
     LazyMetadataStorage.load(resolvers);
     TypeMetadataStorage.compile(options.orphanedTypes);
 
-    this.typeDefinitionsGenerator.generate(options);
+    // includeModules is passed internally from GraphQLSchemaBuilder
+    const internalOptions = options as InternalBuildSchemaOptions;
+    this.typeDefinitionsGenerator.generate(
+      options,
+      internalOptions.includeModules,
+    );
 
     const schema = new GraphQLSchema({
       mutation: this.mutationTypeFactory.create(resolvers, options),

packages/graphql/lib/schema-builder/metadata/class.metadata.ts

@@ -1,6 +1,15 @@
 import { DirectiveMetadata } from './directive.metadata';
 import { PropertyMetadata } from './property.metadata';
 
+/**
+ * Type for the registerIn option used in GraphQL type decorators.
+ * Can be a module class directly or a function that returns the module class
+ * (useful to avoid circular dependency issues).
+ *
+ * @publicApi
+ */
+export type RegisterInOption = Function | (() => Function);
+
 export interface ClassMetadata {
   target: Function;
   name: string;
@@ -11,4 +20,9 @@ export interface ClassMetadata {
   properties?: PropertyMetadata[];
   inheritDescription?: boolean;
   isOneOf?: boolean; // For '@oneOf' input types
+  /**
+   * NestJS module that this type belongs to.
+   * @see RegisterInOption for details
+   */
+  registerIn?: RegisterInOption;
 }

packages/graphql/lib/schema-builder/metadata/enum.metadata.ts

@@ -1,3 +1,5 @@
+import { RegisterInOption } from './class.metadata';
+
 export interface EnumMetadataValuesMapOptions {
   deprecationReason?: string;
   description?: string;
@@ -12,4 +14,9 @@ export interface EnumMetadata<T extends object = any> {
   name: string;
   description?: string;
   valuesMap?: EnumMetadataValuesMap<T>;
+  /**
+   * NestJS module that this enum belongs to.
+   * @see RegisterInOption for details
+   */
+  registerIn?: RegisterInOption;
 }

packages/graphql/lib/schema-builder/metadata/union.metadata.ts

@@ -1,5 +1,6 @@
 import { Type } from '@nestjs/common';
 import { ResolveTypeFn } from '../../interfaces';
+import { RegisterInOption } from './class.metadata';
 
 export interface UnionMetadata<
   T extends readonly Type<unknown>[] = readonly Type<unknown>[],
@@ -9,4 +10,9 @@ export interface UnionMetadata<
   id?: symbol;
   description?: string;
   resolveType?: ResolveTypeFn;
+  /**
+   * NestJS module that this union belongs to.
+   * @see RegisterInOption for details
+   */
+  registerIn?: RegisterInOption;
 }

packages/graphql/lib/schema-builder/storages/type-definitions.storage.ts

@@ -150,4 +150,18 @@ export class TypeDefinitionsStorage {
     }
     return;
   }
+
+  /**
+   * Clear all type definitions.
+   * Used when generating multiple schemas with different module configurations.
+   */
+  clear() {
+    this.interfaceTypeDefinitions.clear();
+    this.enumTypeDefinitions.clear();
+    this.unionTypeDefinitions.clear();
+    this.objectTypeDefinitions.clear();
+    this.inputTypeDefinitions.clear();
+    this.inputTypeDefinitionsLinks = undefined;
+    this.outputTypeDefinitionsLinks = undefined;
+  }
 }