@gqlkit-ts/cli 0.6.0 → 0.7.1

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";
@@ -61,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 {
@@ -82,6 +84,7 @@ interface TypesResult {
   detectedScalars: ReadonlyArray<ScalarMetadataInfo>;
   collectedScalars: ReadonlyArray<CollectedScalarType>;
   scalarMappingTable: ScalarBaseTypeMappingTable | null;
+  discoveredTypeNames: ReadonlySet<string>;
 }
 
 interface ResolversResult {
@@ -251,6 +254,7 @@ function extractTypesCore(params: ExtractTypesCoreParams): TypesResult {
     detectedScalars: extractionResult.detectedScalars,
     collectedScalars,
     scalarMappingTable,
+    discoveredTypeNames: extractionResult.discoveredTypeNames,
   };
 }
 
@@ -632,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 ||
@@ -723,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({
@@ -742,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];
@@ -796,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/extractor/define-api-extractor.ts

@@ -620,6 +620,8 @@ export function extractDefineApiResolvers(
     sourceFiles,
     scalarMappingTable,
     scalarMappingContext: "input",
+    discoveredTypes: null,
+    diagnostics: [],
   };
   const outputContext: FieldTypeResolverContext = {
     checker,
@@ -630,6 +632,8 @@ export function extractDefineApiResolvers(
     sourceFiles,
     scalarMappingTable,
     scalarMappingContext: "output",
+    discoveredTypes: null,
+    diagnostics: [],
   };
 
   for (const filePath of files) {

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";
@@ -19,6 +20,7 @@ import type {
   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.";
@@ -374,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(
@@ -406,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();
 
@@ -417,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(
@@ -424,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));
     }

package/src/schema-generator/emitter/discriminator-resolve-type-emitter.ts

@@ -0,0 +1,125 @@
+import type {
+  DiscriminatorResolveTypeInfo,
+  DiscriminatorValueMapping,
+} from "../../auto-type-generator/discriminator-resolve-type-generator.js";
+
+/**
+ * Groups value mappings by their value at a given field index.
+ * Null values at the field index mean the member doesn't have that field,
+ * so the member should be resolved directly at the current switch level.
+ */
+function groupMappingsByFieldValue(
+  mappings: ReadonlyArray<DiscriminatorValueMapping>,
+  fieldIndex: number,
+): Map<string | null, DiscriminatorValueMapping[]> {
+  const groups = new Map<string | null, DiscriminatorValueMapping[]>();
+  for (const mapping of mappings) {
+    const value = mapping.values[fieldIndex] ?? null;
+    const group = groups.get(value) ?? [];
+    group.push(mapping);
+    groups.set(value, group);
+  }
+  return groups;
+}
+
+/**
+ * Builds a switch statement body for a given field level, recursing for nested fields.
+ * Returns an array of code lines (without leading indentation for the switch itself).
+ */
+function buildSwitchBody(
+  mappings: ReadonlyArray<DiscriminatorValueMapping>,
+  fieldNames: ReadonlyArray<string>,
+  fieldIndex: number,
+  indent: string,
+): string[] {
+  const fieldName = fieldNames[fieldIndex]!;
+  const groups = groupMappingsByFieldValue(mappings, fieldIndex);
+  const lines: string[] = [];
+
+  lines.push(`${indent}switch (obj.${fieldName}) {`);
+
+  for (const [value, groupMappings] of groups) {
+    // Null value means the member doesn't have this field — resolved at the parent level
+    if (value === null) {
+      for (const mapping of groupMappings) {
+        lines.push(
+          `${indent}  case "${mapping.values[fieldIndex - 1]!}": return "${mapping.memberGraphQLTypeName}";`,
+        );
+      }
+      continue;
+    }
+
+    const nextFieldIndex = fieldIndex + 1;
+    const hasMoreFields = nextFieldIndex < fieldNames.length;
+
+    // Check if all mappings in this group can be resolved directly
+    // (either no more fields, or only one mapping, or all remaining values are null)
+    const canResolveDirectly =
+      groupMappings.length === 1 &&
+      (!hasMoreFields || groupMappings[0]!.values[nextFieldIndex] === null);
+
+    if (!hasMoreFields || canResolveDirectly) {
+      // Single mapping or no more fields: emit direct return
+      if (groupMappings.length === 1) {
+        lines.push(
+          `${indent}  case "${value}": return "${groupMappings[0]!.memberGraphQLTypeName}";`,
+        );
+      } else {
+        // Multiple mappings at the leaf level — shouldn't happen with unique tuples
+        for (const mapping of groupMappings) {
+          lines.push(
+            `${indent}  case "${value}": return "${mapping.memberGraphQLTypeName}";`,
+          );
+        }
+      }
+    } else {
+      // Need nested switch for remaining fields
+      lines.push(`${indent}  case "${value}":`);
+      const nestedLines = buildSwitchBody(
+        groupMappings,
+        fieldNames,
+        nextFieldIndex,
+        `${indent}    `,
+      );
+      lines.push(...nestedLines);
+    }
+  }
+
+  lines.push(`${indent}  default: return undefined;`);
+  lines.push(`${indent}}`);
+
+  return lines;
+}
+
+function buildObjTypeAnnotation(fieldNames: ReadonlyArray<string>): string {
+  const fields = fieldNames.map((name) => `${name}: string`);
+  return `{ ${fields.join("; ")} }`;
+}
+
+/**
+ * Builds a resolver map entry for a discriminator-based __resolveType.
+ *
+ * For single discriminator field:
+ *   TypeName: {
+ *     __resolveType: (obj: { field: string }) => {
+ *       switch (obj.field) {
+ *         case "val": return "MemberType";
+ *         default: return undefined;
+ *       }
+ *     },
+ *   },
+ *
+ * For multiple discriminator fields, generates nested switch statements.
+ */
+export function buildDiscriminatorResolveTypeEntry(
+  info: DiscriminatorResolveTypeInfo,
+): string {
+  const { unionTypeName, fieldNames, valueMappings } = info;
+  const objType = buildObjTypeAnnotation(fieldNames);
+  const baseIndent = "        ";
+
+  const switchLines = buildSwitchBody(valueMappings, fieldNames, 0, baseIndent);
+  const switchBody = switchLines.join("\n");
+
+  return `    ${unionTypeName}: {\n      __resolveType: (obj: ${objType}) => {\n${switchBody}\n      },\n    },`;
+}

package/src/schema-generator/generate-schema.ts

@@ -1,12 +1,16 @@
 import {
+  collectDiscriminatorResolveTypes,
   collectTypenameExtractions,
   collectTypenameResolveTypes,
+  flattenIntersectionMembers,
   generateAutoTypes,
+  validateDiscriminatorFields,
   validateNameCollisions,
   validateSchemaTypenames,
   validateTypenames,
 } from "../auto-type-generator/index.js";
 import type { ImportExtension } from "../config/types.js";
+import type { ResolvedDiscriminatorFieldsMap } from "../config-loader/index.js";
 import type { ExtractResolversResult } from "../resolver-extractor/index.js";
 import type { DirectiveDefinitionInfo } from "../shared/directive-definition-extractor.js";
 import type { CollectedScalarType } from "../type-extractor/collector/scalar-collector.js";
@@ -35,6 +39,7 @@ export interface GenerateSchemaInput {
   readonly sourceRoot: string | null;
   readonly knownTypeNames: ReadonlySet<string> | null;
   readonly importExtension: ImportExtension;
+  readonly discriminatorFields: ResolvedDiscriminatorFieldsMap;
 }
 
 export interface GenerateSchemaResult {
@@ -67,6 +72,7 @@ export function generateSchema(
     extractedTypes,
     resolversResult,
     knownTypeNames: knownTypeNames ?? new Set(),
+    discriminatorFields: input.discriminatorFields,
   });
 
   const autoTypeErrors = autoTypeResult.diagnostics.filter(
@@ -105,11 +111,52 @@ export function generateSchema(
     };
   }
 
+  // Flatten intersection-expanded inline object members for discriminator unions.
+  // TypeScript distributes intersections over unions, creating duplicate members
+  // that must be merged before discriminator field validation.
+  const flattenedExtractedTypes = flattenIntersectionMembers({
+    extractedTypes: autoTypeResult.updatedExtractedTypes,
+    discriminatorFields: input.discriminatorFields,
+  });
+
   // Re-convert to GraphQL types using updated extracted types
   // This resolves __INLINE_OBJECT__ references to auto-generated type names
-  const updatedConversionResult = convertToGraphQL(
-    autoTypeResult.updatedExtractedTypes,
+  const updatedConversionResult = convertToGraphQL(flattenedExtractedTypes);
+  const typeMap = new Map(
+    flattenedExtractedTypes.map((t) => [t.metadata.name, t]),
   );
+
+  // Validate discriminator fields against extracted types
+  const inlineDiscriminatorUnionNames = new Set(
+    autoTypeResult.inlineDiscriminatorResolveTypes.map(
+      (rt) => rt.unionTypeName,
+    ),
+  );
+  const discriminatorValidationResult = validateDiscriminatorFields({
+    discriminatorFields: input.discriminatorFields,
+    extractedTypes: flattenedExtractedTypes,
+    typeMap,
+    inlineDiscriminatorUnionNames,
+  });
+  const discriminatorErrors = discriminatorValidationResult.diagnostics.filter(
+    (d) => d.severity === "error",
+  );
+  if (discriminatorErrors.length > 0) {
+    return {
+      typeDefsCode: "",
+      sdlContent: "",
+      resolversCode: "",
+      diagnostics: discriminatorValidationResult.diagnostics,
+      hasErrors: true,
+      prunedTypes: null,
+    };
+  }
+
+  const discriminatorWarnings =
+    discriminatorValidationResult.diagnostics.filter(
+      (d) => d.severity === "warning",
+    );
+
   const updatedTypesResult: ExtractTypesResult = {
     types: updatedConversionResult.types,
     diagnostics: {
@@ -126,29 +173,48 @@ export function generateSchema(
           (d) => d.severity === "warning",
         ),
         ...autoTypeResult.diagnostics.filter((d) => d.severity === "warning"),
+        ...discriminatorWarnings,
       ],
     },
   };
 
-  const typeMap = new Map(
-    autoTypeResult.updatedExtractedTypes.map((t) => [t.metadata.name, t]),
-  );
-
   const manualResolveTypeNames = new Set(
     autoTypeResult.updatedResolversResult.abstractTypeResolvers
       .filter((r) => r.kind === "resolveType")
       .map((r) => r.targetTypeName),
   );
 
+  // Collect discriminator resolve types from validated entries
+  const discriminatorResolveTypesResult = collectDiscriminatorResolveTypes({
+    validatedEntries: discriminatorValidationResult.validatedEntries,
+    manualResolveTypeNames,
+    extractedTypes: flattenedExtractedTypes,
+    typeMap,
+  });
+
+  // Merge inline discriminator resolveTypes from auto-type generation
+  // (for inline unions flattened by discriminator fields, e.g. UIMessagePart<...>[])
+  const mergedDiscriminatorResolveTypes = [
+    ...discriminatorResolveTypesResult.discriminatorResolveTypes,
+    ...autoTypeResult.inlineDiscriminatorResolveTypes,
+  ];
+  // discriminatorResolveTypeNames are derived by integrate() from the merged list
+
+  const discriminatorFieldUnionNames = new Set(
+    input.discriminatorFields.keys(),
+  );
+
   const typenameResolveTypesResult = collectTypenameResolveTypes({
-    extractedTypes: autoTypeResult.updatedExtractedTypes,
+    extractedTypes: flattenedExtractedTypes,
     typeMap,
     manualResolveTypeNames,
+    discriminatorFieldUnionNames,
   });
 
   const typenameExtractions = collectTypenameExtractions({
-    extractedTypes: autoTypeResult.updatedExtractedTypes,
+    extractedTypes: flattenedExtractedTypes,
     typeMap,
+    discriminatorFieldUnionNames,
   });
 
   const typenameValidationDiagnostics: Diagnostic[] = [];
@@ -167,7 +233,7 @@ export function generateSchema(
   }
 
   const schemaTypenameValidationResult = validateSchemaTypenames({
-    objectTypes: autoTypeResult.updatedExtractedTypes,
+    objectTypes: flattenedExtractedTypes,
     typeMap,
   });
   typenameValidationDiagnostics.push(
@@ -188,20 +254,38 @@ export function generateSchema(
   const generatedInlineObjectTypes =
     typenameResolveTypesResult.generatedInlineObjectTypes;
 
+  // Collect all generated object types that need to be added as union members
+  // (both typename-based and discriminator-based inline objects)
+  const discriminatorGeneratedObjectTypes =
+    discriminatorResolveTypesResult.generatedObjectTypes;
+
   const updatedTypesForIntegration: ExtractTypesResult =
-    generatedInlineObjectTypes.length > 0
+    generatedInlineObjectTypes.length > 0 ||
+    discriminatorGeneratedObjectTypes.length > 0
       ? {
           types: updatedTypesResult.types.map((type) => {
             if (type.kind !== "Union") {
               return type;
             }
-            const inlineTypes = generatedInlineObjectTypes.filter(
+            const typenameInlineTypes = generatedInlineObjectTypes.filter(
               (g) => g.abstractTypeName === type.name,
             );
-            if (inlineTypes.length === 0) {
+            const discriminatorInlineTypes =
+              discriminatorGeneratedObjectTypes.filter(
+                (g) =>
+                  g.generatedFrom !== null &&
+                  g.generatedFrom.parentTypeName === type.name,
+              );
+            if (
+              typenameInlineTypes.length === 0 &&
+              discriminatorInlineTypes.length === 0
+            ) {
               return type;
             }
-            const newMembers = inlineTypes.map((g) => g.typeName);
+            const newMembers = [
+              ...typenameInlineTypes.map((g) => g.typeName),
+              ...discriminatorInlineTypes.map((g) => g.name),
+            ];
             return {
               ...type,
               unionMembers: [
@@ -217,6 +301,7 @@ export function generateSchema(
   const allAutoGeneratedTypes = [
     ...autoTypeResult.autoGeneratedTypes,
     ...typenameResolveTypesResult.generatedObjectTypes,
+    ...discriminatorGeneratedObjectTypes,
   ];
 
   const integratedResult = integrate({
@@ -227,6 +312,8 @@ export function generateSchema(
     directiveDefinitions,
     autoGeneratedTypes: allAutoGeneratedTypes,
     typenameAutoResolveTypes: typenameResolveTypesResult.autoResolveTypes,
+    discriminatorResolveTypes: mergedDiscriminatorResolveTypes,
+    tsAliasToGraphQLNameMap: autoTypeResult.tsAliasToGraphQLNameMap,
   });
 
   let documentNode = buildDocumentNode(integratedResult, { sourceRoot });

package/src/schema-generator/integrator/result-integrator.ts

@@ -1,3 +1,4 @@
+import type { DiscriminatorResolveTypeInfo } from "../../auto-type-generator/discriminator-resolve-type-generator.js";
 import type {
   AutoGeneratedType,
   ResolveTypeFieldPattern,
@@ -141,6 +142,7 @@ export interface IntegratedResult {
   readonly abstractTypeResolvers: ReadonlyArray<AbstractResolverInfo>;
   readonly autoGeneratedUnions: ReadonlyArray<AutoGeneratedUnionInfo>;
   readonly typenameAutoResolveTypes: ReadonlyArray<TypenameAutoResolveTypeInfo>;
+  readonly discriminatorResolveTypes: ReadonlyArray<DiscriminatorResolveTypeInfo>;
   readonly numericEnums: ReadonlyArray<NumericEnumInfo>;
   readonly stringEnumMappings: ReadonlyArray<StringEnumMappingInfo>;
   readonly hasQuery: boolean;
@@ -276,6 +278,8 @@ export interface IntegrateParams {
   readonly directiveDefinitions: ReadonlyArray<DirectiveDefinitionInfo> | null;
   readonly autoGeneratedTypes: ReadonlyArray<AutoGeneratedType> | null;
   readonly typenameAutoResolveTypes: ReadonlyArray<TypenameAutoResolveTypeInfo> | null;
+  readonly discriminatorResolveTypes: ReadonlyArray<DiscriminatorResolveTypeInfo> | null;
+  readonly tsAliasToGraphQLNameMap: ReadonlyMap<string, string> | null;
 }
 
 export function integrate(params: IntegrateParams): IntegratedResult {
@@ -287,6 +291,8 @@ export function integrate(params: IntegrateParams): IntegratedResult {
     directiveDefinitions,
     autoGeneratedTypes,
     typenameAutoResolveTypes,
+    discriminatorResolveTypes,
+    tsAliasToGraphQLNameMap,
   } = params;
   const directiveTypeAliasNames = new Set(
     directiveDefinitions?.map((d) => d.typeAliasName) ?? [],
@@ -527,15 +533,32 @@ export function integrate(params: IntegrateParams): IntegratedResult {
     ...autoGeneratedUnions
       .filter((u) => u.hasAutoResolveType)
       .map((u) => u.name),
+    ...(discriminatorResolveTypes?.map((t) => t.unionTypeName) ?? []),
   ]);
 
+  const aliasMap = tsAliasToGraphQLNameMap ?? new Map<string, string>();
+
   const abstractResolverValidation = validateAbstractResolvers({
     abstractResolvers: resolversResult.abstractTypeResolvers,
     baseTypes,
     typenameAutoResolveTypeNames,
+    tsAliasToGraphQLNameMap: aliasMap,
   });
   diagnostics.push(...abstractResolverValidation.diagnostics);
 
+  // Remap abstract resolver target type names from TS aliases to GraphQL names
+  // Only remap resolveType resolvers — isTypeOf targets object types, not unions
+  const remappedAbstractResolvers =
+    aliasMap.size > 0
+      ? resolversResult.abstractTypeResolvers.map((resolver) => {
+          if (resolver.kind !== "resolveType") return resolver;
+          const mappedName = aliasMap.get(resolver.targetTypeName);
+          return mappedName !== undefined
+            ? { ...resolver, targetTypeName: mappedName }
+            : resolver;
+        })
+      : resolversResult.abstractTypeResolvers;
+
   const knownTypeNames = new Set([
     ...baseTypes.map((t) => t.name),
     ...inputTypes.map((t) => t.name),
@@ -733,9 +756,10 @@ export function integrate(params: IntegrateParams): IntegratedResult {
       directiveDefinitions && directiveDefinitions.length > 0
         ? directiveDefinitions
         : null,
-    abstractTypeResolvers: resolversResult.abstractTypeResolvers,
+    abstractTypeResolvers: remappedAbstractResolvers,
     autoGeneratedUnions,
     typenameAutoResolveTypes: typenameAutoResolveTypes ?? [],
+    discriminatorResolveTypes: discriminatorResolveTypes ?? [],
     numericEnums,
     stringEnumMappings,
     hasQuery,

package/src/schema-generator/resolver-collector/resolver-collector.ts

@@ -1,3 +1,4 @@
+import type { DiscriminatorResolveTypeInfo } from "../../auto-type-generator/discriminator-resolve-type-generator.js";
 import type { AutoGeneratedResolveType } from "../../auto-type-generator/resolve-type-generator.js";
 import type { AbstractResolverInfo } from "../../resolver-extractor/extractor/define-api-extractor.js";
 import type {
@@ -30,6 +31,7 @@ export interface ResolverInfo {
   readonly sourceFiles: ReadonlyArray<string>;
   readonly abstractTypeResolvers: ReadonlyArray<AbstractTypeResolverInfo>;
   readonly autoGeneratedResolveTypes: ReadonlyArray<AutoGeneratedResolveType>;
+  readonly discriminatorResolveTypes: ReadonlyArray<DiscriminatorResolveTypeInfo>;
 }
 
 function getResolverValueName(typeName: string): string {
@@ -148,10 +150,15 @@ export function collectResolverInfo(
 
   const sourceFiles = [...sourceFilesSet].sort((a, b) => a.localeCompare(b));
 
+  const discriminatorResolveTypes = [
+    ...integratedResult.discriminatorResolveTypes,
+  ].sort((a, b) => a.unionTypeName.localeCompare(b.unionTypeName));
+
   return {
     types,
     sourceFiles,
     abstractTypeResolvers,
     autoGeneratedResolveTypes,
+    discriminatorResolveTypes,
   };
 }

package/src/shared/constants.ts

@@ -39,6 +39,19 @@ const TS_ANONYMOUS_TYPE_SYMBOL = "__type";
  */
 const TS_ARRAY_TYPE_SYMBOL = "Array";
 
+/**
+ * Object literal type symbol name.
+ *
+ * TypeScript uses `__object` as the internal symbol name for object literal
+ * expressions (value-space). This differs from `__type` which is used for
+ * anonymous object types in type-space.
+ *
+ * This commonly occurs when a type is derived via `typeof` from a variable
+ * initialized with an object literal, especially when the value comes from
+ * an external library.
+ */
+const TS_OBJECT_LITERAL_TYPE_SYMBOL = "__object";
+
 /**
  * Checks if a symbol name represents a TypeScript internal/anonymous type
  * that should not be used directly as a GraphQL type name.
@@ -49,7 +62,8 @@ const TS_ARRAY_TYPE_SYMBOL = "Array";
 export function isInternalTypeSymbol(symbolName: string): boolean {
   return (
     symbolName === TS_ANONYMOUS_TYPE_SYMBOL ||
-    symbolName === TS_ARRAY_TYPE_SYMBOL
+    symbolName === TS_ARRAY_TYPE_SYMBOL ||
+    symbolName === TS_OBJECT_LITERAL_TYPE_SYMBOL
   );
 }