@gqlkit-ts/cli 0.5.1 → 0.7.0

package/src/config-loader/validator.ts

@@ -6,6 +6,7 @@ import {
   DEFAULT_SOURCE_DIR,
   DEFAULT_TYPEDEFS_PATH,
   type ResolvedConfig,
+  type ResolvedDiscriminatorFieldsMap,
   type ResolvedHooksConfig,
   type ResolvedOutputConfig,
   type ResolvedScalarMapping,
@@ -584,6 +585,96 @@ function validateHooksConfig(
   return { resolved: undefined, diagnostics };
 }
 
+function validateDiscriminatorFieldsConfig(
+  value: unknown,
+  configPath: string,
+): {
+  resolved: ResolvedDiscriminatorFieldsMap | undefined;
+  diagnostics: Diagnostic[];
+} {
+  const diagnostics: Diagnostic[] = [];
+
+  if (value === undefined) {
+    return { resolved: new Map(), diagnostics: [] };
+  }
+
+  if (!isRecord(value)) {
+    diagnostics.push({
+      code: "CONFIG_INVALID_DISCRIMINATOR_FIELDS",
+      message: "discriminatorFields must be an object",
+      severity: "error",
+      location: { file: configPath, line: 1, column: 1 },
+    });
+    return { resolved: undefined, diagnostics };
+  }
+
+  const result = new Map<string, ReadonlyArray<string>>();
+
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string") {
+      if (entry === "") {
+        diagnostics.push({
+          code: "CONFIG_EMPTY_DISCRIMINATOR_FIELDS",
+          message: `discriminatorFields["${key}"] cannot be an empty string`,
+          severity: "error",
+          location: { file: configPath, line: 1, column: 1 },
+        });
+        continue;
+      }
+      result.set(key, [entry]);
+    } else if (Array.isArray(entry)) {
+      if (entry.length === 0) {
+        diagnostics.push({
+          code: "CONFIG_EMPTY_DISCRIMINATOR_FIELDS",
+          message: `discriminatorFields["${key}"] cannot be an empty array`,
+          severity: "error",
+          location: { file: configPath, line: 1, column: 1 },
+        });
+        continue;
+      }
+      let hasError = false;
+      for (const item of entry) {
+        if (typeof item !== "string") {
+          diagnostics.push({
+            code: "CONFIG_INVALID_DISCRIMINATOR_ENTRY",
+            message: `discriminatorFields["${key}"] array must contain only strings`,
+            severity: "error",
+            location: { file: configPath, line: 1, column: 1 },
+          });
+          hasError = true;
+          break;
+        }
+        if (item === "") {
+          diagnostics.push({
+            code: "CONFIG_EMPTY_DISCRIMINATOR_FIELDS",
+            message: `discriminatorFields["${key}"] array contains an empty string`,
+            severity: "error",
+            location: { file: configPath, line: 1, column: 1 },
+          });
+          hasError = true;
+          break;
+        }
+      }
+      if (!hasError) {
+        result.set(key, entry as string[]);
+      }
+    } else {
+      diagnostics.push({
+        code: "CONFIG_INVALID_DISCRIMINATOR_ENTRY",
+        message: `discriminatorFields["${key}"] must be a string or array of strings`,
+        severity: "error",
+        location: { file: configPath, line: 1, column: 1 },
+      });
+    }
+  }
+
+  if (diagnostics.length > 0) {
+    return { resolved: undefined, diagnostics };
+  }
+
+  return { resolved: result, diagnostics: [] };
+}
+
 export function validateConfig(
   options: ValidateConfigOptions,
 ): ValidateConfigResult {
@@ -621,6 +712,12 @@ export function validateConfig(
   const hooksResult = validateHooksConfig(config["hooks"], configPath);
   diagnostics.push(...hooksResult.diagnostics);
 
+  const discriminatorFieldsResult = validateDiscriminatorFieldsConfig(
+    config["discriminatorFields"],
+    configPath,
+  );
+  diagnostics.push(...discriminatorFieldsResult.diagnostics);
+
   if (config["scalars"] !== undefined && !Array.isArray(config["scalars"])) {
     diagnostics.push({
       code: "CONFIG_INVALID_TYPE",
@@ -685,7 +782,8 @@ export function validateConfig(
     !sourceDirResult.resolved ||
     !sourceIgnoreGlobsResult.resolved ||
     !outputResult.resolved ||
-    !hooksResult.resolved
+    !hooksResult.resolved ||
+    !discriminatorFieldsResult.resolved
   ) {
     return { valid: false, resolvedConfig: undefined, diagnostics };
   }
@@ -699,6 +797,7 @@ export function validateConfig(
       scalars: resolvedScalars,
       tsconfigPath: tsconfigPathResult.resolved,
       hooks: hooksResult.resolved,
+      discriminatorFields: discriminatorFieldsResult.resolved,
     },
     diagnostics: [],
   };

package/src/gen-orchestrator/orchestrator.ts

@@ -1,6 +1,7 @@
 import { dirname, relative, resolve } from "node:path";
 import type ts from "typescript";
 import type {
+  ResolvedDiscriminatorFieldsMap,
   ResolvedOutputConfig,
   ResolvedScalarMapping,
 } from "../config-loader/index.js";
@@ -34,6 +35,7 @@ import {
   collectScalars,
   type ScalarMetadataInfo,
 } from "../type-extractor/collector/scalar-collector.js";
+import { isEligibleField } from "../type-extractor/converter/field-eligibility.js";
 import { convertToGraphQL } from "../type-extractor/converter/graphql-converter.js";
 import {
   extractTypesFromProgram,
@@ -60,6 +62,7 @@ export interface GenerationConfig {
   readonly configDir: string | null;
   readonly customScalars: ReadonlyArray<ResolvedScalarMapping> | null;
   readonly tsconfigPath: string | null;
+  readonly discriminatorFields: ResolvedDiscriminatorFieldsMap;
 }
 
 export interface GeneratedFile {
@@ -81,11 +84,13 @@ interface TypesResult {
   detectedScalars: ReadonlyArray<ScalarMetadataInfo>;
   collectedScalars: ReadonlyArray<CollectedScalarType>;
   scalarMappingTable: ScalarBaseTypeMappingTable | null;
+  discoveredTypeNames: ReadonlySet<string>;
 }
 
 interface ResolversResult {
   queryFields: { fields: ReadonlyArray<GraphQLFieldDefinition> };
   mutationFields: { fields: ReadonlyArray<GraphQLFieldDefinition> };
+  subscriptionFields: { fields: ReadonlyArray<GraphQLFieldDefinition> };
   typeExtensions: ReadonlyArray<TypeExtension>;
   abstractTypeResolvers: ReadonlyArray<AbstractResolverInfo>;
   diagnostics: Diagnostics;
@@ -249,6 +254,7 @@ function extractTypesCore(params: ExtractTypesCoreParams): TypesResult {
     detectedScalars: extractionResult.detectedScalars,
     collectedScalars,
     scalarMappingTable,
+    discoveredTypeNames: extractionResult.discoveredTypeNames,
   };
 }
 
@@ -279,20 +285,42 @@ function convertDefineApiToFields(
 ): {
   queryFields: { fields: ReadonlyArray<GraphQLFieldDefinition> };
   mutationFields: { fields: ReadonlyArray<GraphQLFieldDefinition> };
+  subscriptionFields: { fields: ReadonlyArray<GraphQLFieldDefinition> };
   typeExtensions: ReadonlyArray<TypeExtension>;
+  diagnostics: ReadonlyArray<Diagnostic>;
 } {
   const queryFields: GraphQLFieldDefinition[] = [];
   const mutationFields: GraphQLFieldDefinition[] = [];
+  const subscriptionFields: GraphQLFieldDefinition[] = [];
   const typeExtensionMap = new Map<string, GraphQLFieldDefinition[]>();
+  const diagnostics: Diagnostic[] = [];
 
   for (const resolver of resolvers) {
+    const eligibility = isEligibleField({
+      fieldName: resolver.fieldName,
+      kind: "object",
+    });
+    if (!eligibility.eligible) {
+      diagnostics.push({
+        code: "SKIPPED_FIELD",
+        message: eligibility.skipReason.message,
+        severity: "warning",
+        location: {
+          file: resolver.sourceLocation.file,
+          line: resolver.sourceLocation.line,
+          column: resolver.sourceLocation.column,
+        },
+      });
+      continue;
+    }
+
     const returnType = resolver.returnType;
     const fieldDef: GraphQLFieldDefinition = {
       name: resolver.fieldName,
       type: convertTsTypeToGraphQLType(returnType),
       args: resolver.args ? convertArgsToInputValues(resolver.args) : null,
       sourceLocation: resolver.sourceLocation,
-      resolverExportName: resolver.fieldName,
+      resolverExportName: resolver.resolverExportName,
       description: resolver.description,
       deprecated: resolver.deprecated,
       directives: resolver.directives,
@@ -316,6 +344,8 @@ function convertDefineApiToFields(
       queryFields.push(fieldDef);
     } else if (resolver.resolverType === "mutation") {
       mutationFields.push(fieldDef);
+    } else if (resolver.resolverType === "subscription") {
+      subscriptionFields.push(fieldDef);
     } else if (resolver.resolverType === "field" && resolver.parentTypeName) {
       const existing = typeExtensionMap.get(resolver.parentTypeName) ?? [];
       existing.push(fieldDef);
@@ -331,7 +361,9 @@ function convertDefineApiToFields(
   return {
     queryFields: { fields: queryFields },
     mutationFields: { fields: mutationFields },
+    subscriptionFields: { fields: subscriptionFields },
     typeExtensions,
+    diagnostics,
   };
 }
 
@@ -411,9 +443,11 @@ function extractResolversCore(
   allDiagnostics.push(...defineApiExtractionResult.diagnostics);
 
   const result = convertDefineApiToFields(defineApiExtractionResult.resolvers);
+  allDiagnostics.push(...result.diagnostics);
   return {
     queryFields: result.queryFields,
     mutationFields: result.mutationFields,
+    subscriptionFields: result.subscriptionFields,
     typeExtensions: result.typeExtensions,
     abstractTypeResolvers: defineApiExtractionResult.abstractTypeResolvers,
     diagnostics: collectDiagnostics(allDiagnostics),
@@ -602,6 +636,18 @@ function extractTypesStep(ctx: PipelineContext): PipelineContext {
   return { ...ctx, typesResult };
 }
 
+function augmentKnownTypeNamesStep(ctx: PipelineContext): PipelineContext {
+  if (ctx.aborted || !ctx.typesResult || !ctx.knownTypeNames) return ctx;
+
+  if (ctx.typesResult.discoveredTypeNames.size === 0) return ctx;
+
+  const augmented = new Set(ctx.knownTypeNames);
+  for (const name of ctx.typesResult.discoveredTypeNames) {
+    augmented.add(name);
+  }
+  return { ...ctx, knownTypeNames: augmented };
+}
+
 function extractResolversStep(ctx: PipelineContext): PipelineContext {
   if (
     ctx.aborted ||
@@ -693,8 +739,7 @@ function generateSchemaStep(ctx: PipelineContext): {
 
   const { customScalarNames } = ctx.scalarConfig;
   const allCustomScalarNames = [
-    ...customScalarNames,
-    ...ctx.typesResult.detectedScalarNames,
+    ...new Set([...customScalarNames, ...ctx.typesResult.detectedScalarNames]),
   ];
 
   const schemaResult = generateSchema({
@@ -712,6 +757,7 @@ function generateSchemaStep(ctx: PipelineContext): {
     sourceRoot: ctx.config.cwd,
     knownTypeNames: ctx.knownTypeNames,
     importExtension: ctx.config.output.importExtension,
+    discriminatorFields: ctx.config.discriminatorFields,
   });
 
   const newDiagnostics = [...ctx.diagnostics, ...schemaResult.diagnostics];
@@ -766,6 +812,7 @@ export async function executeGeneration(
   ctx = collectTypeNamesStep(ctx);
   ctx = prepareScalarConfigStep(ctx);
   ctx = extractTypesStep(ctx);
+  ctx = augmentKnownTypeNamesStep(ctx);
   ctx = extractResolversStep(ctx);
   ctx = extractDirectivesStep(ctx);
   ctx = validateExtractionStep(ctx);

package/src/resolver-extractor/extract-resolvers.ts

@@ -68,6 +68,10 @@ export interface MutationFieldDefinitions {
   readonly fields: ReadonlyArray<GraphQLFieldDefinition>;
 }
 
+export interface SubscriptionFieldDefinitions {
+  readonly fields: ReadonlyArray<GraphQLFieldDefinition>;
+}
+
 export interface TypeExtension {
   readonly targetTypeName: string;
   readonly fields: ReadonlyArray<GraphQLFieldDefinition>;
@@ -76,6 +80,7 @@ export interface TypeExtension {
 export interface ExtractResolversResult {
   readonly queryFields: QueryFieldDefinitions;
   readonly mutationFields: MutationFieldDefinitions;
+  readonly subscriptionFields: SubscriptionFieldDefinitions;
   readonly typeExtensions: ReadonlyArray<TypeExtension>;
   readonly abstractTypeResolvers: ReadonlyArray<AbstractResolverInfo>;
   readonly diagnostics: Diagnostics;

package/src/resolver-extractor/extractor/define-api-extractor.ts

@@ -35,7 +35,11 @@ import type {
   TSTypeReference,
 } from "../../type-extractor/types/index.js";
 
-export type DefineApiResolverType = "query" | "mutation" | "field";
+export type DefineApiResolverType =
+  | "query"
+  | "mutation"
+  | "field"
+  | "subscription";
 
 export type AbstractResolverKind = "resolveType" | "isTypeOf";
 
@@ -56,6 +60,7 @@ export interface ArgumentDefinition {
 
 export interface DefineApiResolverInfo {
   readonly fieldName: string;
+  readonly resolverExportName: string;
   readonly resolverType: DefineApiResolverType;
   readonly parentTypeName: string | null;
   readonly argsType: TSTypeReference | null;
@@ -222,7 +227,12 @@ function detectResolverFromMetadataType(
   const kindType = checker.getTypeOfSymbol(kindProp);
   if (kindType.isStringLiteral()) {
     const kind = kindType.value;
-    if (kind === "query" || kind === "mutation" || kind === "field") {
+    if (
+      kind === "query" ||
+      kind === "mutation" ||
+      kind === "field" ||
+      kind === "subscription"
+    ) {
       return kind;
     }
   }
@@ -230,6 +240,20 @@ function detectResolverFromMetadataType(
   return null;
 }
 
+function resolveFieldNameFromExportName(exportName: string): string | null {
+  const delimiterIndex = exportName.lastIndexOf("$");
+  if (delimiterIndex === -1) {
+    return exportName;
+  }
+
+  const fieldName = exportName.slice(delimiterIndex + 1);
+  if (fieldName.length === 0) {
+    return null;
+  }
+
+  return fieldName;
+}
+
 function isInlineTypeLiteralDeclaration(declaration: ts.Declaration): boolean {
   if (!ts.isPropertySignature(declaration)) {
     return false;
@@ -596,6 +620,8 @@ export function extractDefineApiResolvers(
     sourceFiles,
     scalarMappingTable,
     scalarMappingContext: "input",
+    discoveredTypes: null,
+    diagnostics: [],
   };
   const outputContext: FieldTypeResolverContext = {
     checker,
@@ -606,6 +632,8 @@ export function extractDefineApiResolvers(
     sourceFiles,
     scalarMappingTable,
     scalarMappingContext: "output",
+    discoveredTypes: null,
+    diagnostics: [],
   };
 
   for (const filePath of files) {
@@ -633,7 +661,7 @@ export function extractDefineApiResolvers(
           continue;
         }
 
-        const fieldName = declaration.name.getText(sourceFile);
+        const exportName = declaration.name.getText(sourceFile);
         const initializer = declaration.initializer;
 
         if (!initializer) {
@@ -647,11 +675,11 @@ export function extractDefineApiResolvers(
           ) {
             const hasDefineCall = initializer
               .getText(sourceFile)
-              .match(/define(Query|Mutation|Field)/);
+              .match(/define(Query|Mutation|Field|Subscription)/);
             if (hasDefineCall) {
               diagnostics.push({
                 code: "INVALID_DEFINE_CALL",
-                message: `Complex expressions with define* functions are not supported. Use a simple 'export const ${fieldName} = defineXxx(...)' pattern.`,
+                message: `Complex expressions with define* functions are not supported. Use a simple 'export const ${exportName} = defineXxx(...)' pattern.`,
                 severity: "error",
                 location: getSourceLocationFromNode(declaration.name),
               });
@@ -671,7 +699,7 @@ export function extractDefineApiResolvers(
             abstractTypeResolvers.push({
               kind: abstractResolverInfo.kind,
               targetTypeName: abstractResolverInfo.targetTypeName,
-              exportName: fieldName,
+              exportName,
               sourceFile: filePath,
               sourceLocation,
             });
@@ -688,6 +716,17 @@ export function extractDefineApiResolvers(
           continue;
         }
 
+        const fieldName = resolveFieldNameFromExportName(exportName);
+        if (fieldName === null) {
+          diagnostics.push({
+            code: "INVALID_DEFINE_CALL",
+            message: `Resolver export '${exportName}' must have a non-empty field name after '$'.`,
+            severity: "error",
+            location: getSourceLocationFromNode(declaration.name),
+          });
+          continue;
+        }
+
         const funcName = ts.isIdentifier(initializer.expression)
           ? initializer.expression.text
           : undefined;
@@ -702,7 +741,7 @@ export function extractDefineApiResolvers(
         if (!typeInfo) {
           diagnostics.push({
             code: "INVALID_DEFINE_CALL",
-            message: `Failed to extract type arguments from ${funcName ?? "define*"} call for '${fieldName}'`,
+            message: `Failed to extract type arguments from ${funcName ?? "define*"} call for '${exportName}'`,
             severity: "error",
             location: getSourceLocationFromNode(declaration.name),
           });
@@ -720,6 +759,7 @@ export function extractDefineApiResolvers(
 
         resolvers.push({
           fieldName,
+          resolverExportName: exportName,
           resolverType,
           parentTypeName: typeInfo.parentTypeName,
           argsType: typeInfo.argsType,

package/src/resolver-extractor/index.ts

@@ -5,6 +5,7 @@ export type {
   GraphQLInputValue,
   MutationFieldDefinitions,
   QueryFieldDefinitions,
+  SubscriptionFieldDefinitions,
   TypeExtension,
 } from "./extract-resolvers.js";
 export type {

package/src/resolver-extractor/validator/abstract-resolver-validator.ts

@@ -17,6 +17,8 @@ export interface ValidateAbstractResolversOptions {
   readonly abstractResolvers: ReadonlyArray<AbstractResolverInfo>;
   readonly baseTypes: ReadonlyArray<BaseType>;
   readonly typenameAutoResolveTypeNames?: ReadonlySet<string>;
+  /** Mapping from TypeScript type alias names to auto-generated GraphQL union names */
+  readonly tsAliasToGraphQLNameMap: ReadonlyMap<string, string>;
 }
 
 export interface ValidateAbstractResolversResult {
@@ -207,7 +209,22 @@ export function validateAbstractResolvers(
     typeMap.set(baseType.name, baseType);
   }
 
-  for (const resolver of options.abstractResolvers) {
+  // Remap resolver target type names using TS alias → GraphQL name mapping
+  // e.g., defineResolveType<ItemPart> where ItemPart is a TS alias
+  // maps to the auto-generated union name "ContainerItems"
+  // Only remap resolveType resolvers — isTypeOf targets object types, not unions
+  const resolvers = options.abstractResolvers.map((resolver) => {
+    if (resolver.kind !== "resolveType") return resolver;
+    const mappedName = options.tsAliasToGraphQLNameMap.get(
+      resolver.targetTypeName,
+    );
+    if (mappedName !== undefined) {
+      return { ...resolver, targetTypeName: mappedName };
+    }
+    return resolver;
+  });
+
+  for (const resolver of resolvers) {
     const targetType = typeMap.get(resolver.targetTypeName);
 
     if (!targetType) {
@@ -241,14 +258,11 @@ export function validateAbstractResolvers(
     }
   }
 
-  const duplicateDiagnostics = detectDuplicateResolvers(
-    options.abstractResolvers,
-    typeMap,
-  );
+  const duplicateDiagnostics = detectDuplicateResolvers(resolvers, typeMap);
   diagnostics.push(...duplicateDiagnostics);
 
   const missingResolverWarnings = detectMissingAbstractTypeResolvers({
-    resolvers: options.abstractResolvers,
+    resolvers,
     typeMap,
     typenameAutoResolveTypeNames:
       options.typenameAutoResolveTypeNames ?? new Set(),

package/src/schema-generator/emitter/code-emitter.ts

@@ -1,4 +1,5 @@
 import path from "node:path";
+import type { DiscriminatorResolveTypeInfo } from "../../auto-type-generator/discriminator-resolve-type-generator.js";
 import type { AutoGeneratedResolveType } from "../../auto-type-generator/resolve-type-generator.js";
 import { TYPENAME_FIELD_NAMES } from "../../auto-type-generator/typename-types.js";
 import type { ImportExtension } from "../../config/types.js";
@@ -15,9 +16,11 @@ import type {
 } from "../integrator/result-integrator.js";
 import type {
   AbstractTypeResolverInfo,
+  FieldResolver,
   ResolverInfo,
   TypeResolvers,
 } from "../resolver-collector/resolver-collector.js";
+import { buildDiscriminatorResolveTypeEntry } from "./discriminator-resolve-type-emitter.js";
 
 const GENERATED_FILE_HEADER =
   "// This file is auto-generated by gqlkit. DO NOT EDIT.";
@@ -315,21 +318,33 @@ function buildStringEnumResolvers(
   return stringEnumMappings.map(buildStringEnumResolver);
 }
 
+function buildFieldResolverValue(
+  localName: string,
+  field: FieldResolver,
+): string {
+  if (field.isDirectExport) {
+    return localName;
+  }
+  return `${localName}.${field.fieldName}`;
+}
+
 function buildTypeResolverEntry(
   type: TypeResolvers,
   abstractResolverForType: AbstractTypeResolverInfo | null,
 ): string {
   const entries: string[] = [];
+  const isSubscription = type.typeName === "Subscription";
 
   for (const field of type.fields) {
     const localName = makeResolverLocalName(type.typeName, field.fieldName);
+    const resolverValue = buildFieldResolverValue(localName, field);
 
-    if (field.isDirectExport) {
-      entries.push(`      ${field.fieldName}: ${localName},`);
-    } else {
+    if (isSubscription) {
       entries.push(
-        `      ${field.fieldName}: ${localName}.${field.fieldName},`,
+        `      ${field.fieldName}: { subscribe: ${resolverValue}, resolve: (event: unknown) => event },`,
       );
+    } else {
+      entries.push(`      ${field.fieldName}: ${resolverValue},`);
     }
   }
 
@@ -361,11 +376,22 @@ function getResolveTypeExpression(
   return expressions.join(" ?? ");
 }
 
+function buildResolveTypeObjType(
+  fieldPattern: AutoGeneratedResolveType["fieldPattern"],
+): string {
+  const fields = TYPENAME_FIELD_NAMES.filter((name) =>
+    fieldPattern.usedFieldNames.has(name),
+  ).map((name) => `${name}: string`);
+
+  return `{ ${fields.join("; ")} }`;
+}
+
 function buildAutoResolveTypeEntry(
   autoResolveType: AutoGeneratedResolveType,
 ): string {
   const expression = getResolveTypeExpression(autoResolveType.fieldPattern);
-  return `    ${autoResolveType.unionTypeName}: {\n      __resolveType: (obj) => ${expression},\n    },`;
+  const objType = buildResolveTypeObjType(autoResolveType.fieldPattern);
+  return `    ${autoResolveType.unionTypeName}: {\n      __resolveType: (obj: ${objType}) => ${expression},\n    },`;
 }
 
 function buildTypeEntries(
@@ -393,10 +419,16 @@ function buildTypeEntries(
     resolverInfo.autoGeneratedResolveTypes.map((r) => [r.unionTypeName, r]),
   );
 
+  const discriminatorResolveTypeByUnion = new Map<
+    string,
+    DiscriminatorResolveTypeInfo
+  >(resolverInfo.discriminatorResolveTypes.map((r) => [r.unionTypeName, r]));
+
   const allTypeNames = new Set<string>([
     ...typesWithFields.keys(),
     ...abstractResolversByType.keys(),
     ...autoResolveTypeByUnion.keys(),
+    ...discriminatorResolveTypeByUnion.keys(),
   ]);
   const sortedTypeNames = [...allTypeNames].sort();
 
@@ -404,6 +436,8 @@ function buildTypeEntries(
     const typeWithFields = typesWithFields.get(typeName);
     const abstractResolver = abstractResolversByType.get(typeName) ?? null;
     const autoResolveType = autoResolveTypeByUnion.get(typeName);
+    const discriminatorResolveType =
+      discriminatorResolveTypeByUnion.get(typeName);
 
     if (typeWithFields !== undefined) {
       typeEntries.push(
@@ -411,6 +445,10 @@ function buildTypeEntries(
       );
     } else if (abstractResolver !== null) {
       typeEntries.push(buildAbstractOnlyTypeEntry(abstractResolver));
+    } else if (discriminatorResolveType !== undefined) {
+      typeEntries.push(
+        buildDiscriminatorResolveTypeEntry(discriminatorResolveType),
+      );
     } else if (autoResolveType !== undefined) {
       typeEntries.push(buildAutoResolveTypeEntry(autoResolveType));
     }