@gqlkit-ts/cli 0.2.0 → 0.4.0

package/src/schema-generator/builder/ast-builder.ts

@@ -48,13 +48,13 @@ import type {
 } from "../integrator/result-integrator.js";
 
 export interface BuildDocumentOptions {
-  readonly sourceRoot?: string;
+  readonly sourceRoot: string | null;
 }
 
 function appendSourceLocation(
   description: string | null,
   sourceFile: string | null,
-  sourceRoot: string | undefined,
+  sourceRoot: string | null,
 ): string | null {
   if (!sourceRoot || !sourceFile) {
     return description;
@@ -113,7 +113,7 @@ function buildOneOfDirective(): ConstDirectiveNode {
 
 function buildDirectiveArgumentValue(
   value: DirectiveArgumentValue,
-  expectedTypeName?: string,
+  expectedTypeName: string | null,
 ): ConstValueNode {
   switch (value.kind) {
     case "string":
@@ -159,7 +159,7 @@ function buildDirectiveArgumentValue(
         fields: value.fields.map((f) => ({
           kind: Kind.OBJECT_FIELD as const,
           name: buildNameNode(f.name),
-          value: buildDirectiveArgumentValue(f.value),
+          value: buildDirectiveArgumentValue(f.value, null),
         })),
       };
   }
@@ -167,7 +167,7 @@ function buildDirectiveArgumentValue(
 
 function buildDirectiveArgument(
   arg: DirectiveArgument,
-  expectedTypeName?: string,
+  expectedTypeName: string | null,
 ): ConstArgumentNode {
   return {
     kind: Kind.ARGUMENT,
@@ -178,7 +178,7 @@ function buildDirectiveArgument(
 
 function buildCustomDirective(
   directive: DirectiveInfo,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): ConstDirectiveNode {
   const def = directiveDefMap?.get(directive.name);
   const argTypeMap = new Map<string, string>();
@@ -189,7 +189,7 @@ function buildCustomDirective(
   }
 
   const args = directive.args.map((arg) =>
-    buildDirectiveArgument(arg, argTypeMap.get(arg.name)),
+    buildDirectiveArgument(arg, argTypeMap.get(arg.name) ?? null),
   );
 
   return {
@@ -202,7 +202,7 @@ function buildCustomDirective(
 function buildDirectives(
   directives: ReadonlyArray<DirectiveInfo> | null,
   deprecated: DeprecationInfo | null,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): ConstDirectiveNode[] {
   const result: ConstDirectiveNode[] = [];
 
@@ -278,7 +278,12 @@ function buildInputValueDefinitionNode(
       ? { description: buildStringValueNode(inputValue.description) }
       : {}),
     ...(inputValue.defaultValue
-      ? { defaultValue: buildDirectiveArgumentValue(inputValue.defaultValue) }
+      ? {
+          defaultValue: buildDirectiveArgumentValue(
+            inputValue.defaultValue,
+            null,
+          ),
+        }
       : {}),
     ...(directives.length > 0 ? { directives } : {}),
   };
@@ -290,7 +295,7 @@ function sortByName<T extends { name: string }>(items: ReadonlyArray<T>): T[] {
 
 function buildBaseFieldDefinitionNode(
   field: BaseField,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): FieldDefinitionNode {
   const directives = buildDirectives(
     field.directives,
@@ -311,8 +316,8 @@ function buildBaseFieldDefinitionNode(
 
 function buildFieldDefinitionNode(
   field: ExtensionField,
-  sourceRoot?: string,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  sourceRoot: string | null,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): FieldDefinitionNode {
   const directives = buildDirectives(
     field.directives,
@@ -338,11 +343,14 @@ function buildFieldDefinitionNode(
   };
 }
 
-function buildObjectTypeDefinitionNode(
+function buildTypeDefinitionNode(
   baseType: BaseType,
-  sourceRoot?: string,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
-): ObjectTypeDefinitionNode {
+  kind:
+    | typeof Kind.OBJECT_TYPE_DEFINITION
+    | typeof Kind.INTERFACE_TYPE_DEFINITION,
+  sourceRoot: string | null,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
+): ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode {
   const sortedFields = baseType.fields ? sortByName(baseType.fields) : [];
   const directives = buildDirectives(
     baseType.directives,
@@ -364,7 +372,7 @@ function buildObjectTypeDefinitionNode(
       : undefined;
 
   return {
-    kind: Kind.OBJECT_TYPE_DEFINITION,
+    kind,
     name: buildNameNode(baseType.name),
     fields: sortedFields.map((f) =>
       buildBaseFieldDefinitionNode(f, directiveDefMap),
@@ -372,49 +380,12 @@ function buildObjectTypeDefinitionNode(
     ...(description ? { description: buildStringValueNode(description) } : {}),
     ...(directives.length > 0 ? { directives } : {}),
     ...(interfaces ? { interfaces } : {}),
-  };
-}
-
-function buildInterfaceTypeDefinitionNode(
-  baseType: BaseType,
-  sourceRoot?: string,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
-): InterfaceTypeDefinitionNode {
-  const sortedFields = baseType.fields ? sortByName(baseType.fields) : [];
-  const directives = buildDirectives(
-    baseType.directives,
-    baseType.deprecated,
-    directiveDefMap,
-  );
-
-  const description = appendSourceLocation(
-    baseType.description,
-    baseType.sourceFile,
-    sourceRoot,
-  );
-
-  const interfaces =
-    baseType.implementedInterfaces && baseType.implementedInterfaces.length > 0
-      ? [...baseType.implementedInterfaces]
-          .sort((a, b) => a.localeCompare(b))
-          .map(buildNamedTypeNode)
-      : undefined;
-
-  return {
-    kind: Kind.INTERFACE_TYPE_DEFINITION,
-    name: buildNameNode(baseType.name),
-    fields: sortedFields.map((f) =>
-      buildBaseFieldDefinitionNode(f, directiveDefMap),
-    ),
-    ...(description ? { description: buildStringValueNode(description) } : {}),
-    ...(directives.length > 0 ? { directives } : {}),
-    ...(interfaces ? { interfaces } : {}),
-  };
+  } as ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode;
 }
 
 function buildUnionTypeDefinitionNode(
   baseType: BaseType,
-  sourceRoot?: string,
+  sourceRoot: string | null,
 ): UnionTypeDefinitionNode {
   const sortedMembers = baseType.unionMembers
     ? [...baseType.unionMembers].sort((a, b) => a.localeCompare(b))
@@ -454,7 +425,7 @@ function buildEnumValueDefinitionNode(
 
 function buildEnumTypeDefinitionNode(
   baseType: BaseType,
-  sourceRoot?: string,
+  sourceRoot: string | null,
 ): EnumTypeDefinitionNode {
   const enumValues = baseType.enumValues ?? [];
 
@@ -474,7 +445,7 @@ function buildEnumTypeDefinitionNode(
 
 function buildScalarTypeDefinitionNode(
   name: string,
-  description?: string,
+  description: string | null,
 ): ScalarTypeDefinitionNode {
   return {
     kind: Kind.SCALAR_TYPE_DEFINITION,
@@ -485,7 +456,7 @@ function buildScalarTypeDefinitionNode(
 
 function buildInputFieldDefinitionNode(
   field: BaseField,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): InputValueDefinitionNode {
   const directives = buildDirectives(
     field.directives,
@@ -501,7 +472,7 @@ function buildInputFieldDefinitionNode(
       ? { description: buildStringValueNode(field.description) }
       : {}),
     ...(field.defaultValue
-      ? { defaultValue: buildDirectiveArgumentValue(field.defaultValue) }
+      ? { defaultValue: buildDirectiveArgumentValue(field.defaultValue, null) }
       : {}),
     ...(directives.length > 0 ? { directives } : {}),
   };
@@ -509,8 +480,8 @@ function buildInputFieldDefinitionNode(
 
 function buildInputObjectTypeDefinitionNode(
   inputType: InputType,
-  sourceRoot?: string,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  sourceRoot: string | null,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): InputObjectTypeDefinitionNode {
   const sortedFields = sortByName(inputType.fields);
 
@@ -538,8 +509,8 @@ function buildInputObjectTypeDefinitionNode(
 
 function buildObjectTypeExtensionNode(
   typeExtension: TypeExtension,
-  sourceRoot?: string,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  sourceRoot: string | null,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): ObjectTypeExtensionNode {
   const sortedFields = sortByName(typeExtension.fields);
   return {
@@ -553,8 +524,8 @@ function buildObjectTypeExtensionNode(
 
 function buildInterfaceTypeExtensionNode(
   typeExtension: TypeExtension,
-  sourceRoot?: string,
-  directiveDefMap?: Map<string, DirectiveDefinitionInfo>,
+  sourceRoot: string | null,
+  directiveDefMap: Map<string, DirectiveDefinitionInfo> | null,
 ): InterfaceTypeExtensionNode {
   const sortedFields = sortByName(typeExtension.fields);
   return {
@@ -600,9 +571,9 @@ function buildDirectiveDefinitionNode(
 
 export function buildDocumentNode(
   integratedResult: IntegratedResult,
-  options?: BuildDocumentOptions,
+  options: BuildDocumentOptions,
 ): DocumentNode {
-  const sourceRoot = options?.sourceRoot;
+  const sourceRoot = options.sourceRoot;
   const definitions: DefinitionNode[] = [];
 
   // Build directive definition map for argument type lookup
@@ -628,19 +599,9 @@ export function buildDocumentNode(
     );
     for (const scalar of sortedScalars) {
       definitions.push(
-        buildScalarTypeDefinitionNode(
-          scalar.scalarName,
-          scalar.description ?? undefined,
-        ),
+        buildScalarTypeDefinitionNode(scalar.scalarName, scalar.description),
       );
     }
-  } else if (integratedResult.customScalarNames) {
-    const sortedScalarNames = [...integratedResult.customScalarNames].sort(
-      (a, b) => a.localeCompare(b),
-    );
-    for (const scalarName of sortedScalarNames) {
-      definitions.push(buildScalarTypeDefinitionNode(scalarName));
-    }
   }
 
   const sortedBaseTypes = [...integratedResult.baseTypes].sort((a, b) =>
@@ -650,11 +611,21 @@ export function buildDocumentNode(
   for (const baseType of sortedBaseTypes) {
     if (baseType.kind === "Interface") {
       definitions.push(
-        buildInterfaceTypeDefinitionNode(baseType, sourceRoot, directiveDefMap),
+        buildTypeDefinitionNode(
+          baseType,
+          Kind.INTERFACE_TYPE_DEFINITION,
+          sourceRoot,
+          directiveDefMap,
+        ),
       );
     } else if (baseType.kind === "Object") {
       definitions.push(
-        buildObjectTypeDefinitionNode(baseType, sourceRoot, directiveDefMap),
+        buildTypeDefinitionNode(
+          baseType,
+          Kind.OBJECT_TYPE_DEFINITION,
+          sourceRoot,
+          directiveDefMap,
+        ),
       );
     } else if (baseType.kind === "Union") {
       definitions.push(buildUnionTypeDefinitionNode(baseType, sourceRoot));

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

@@ -1,4 +1,7 @@
 import path from "node:path";
+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";
 import { toPosixPath } from "../../shared/index.js";
 import type { CollectedScalarType } from "../../type-extractor/collector/scalar-collector.js";
 import {
@@ -21,7 +24,7 @@ const GENERATED_FILE_HEADER =
 
 function formatDocumentNodeAsCode(
   integratedResult: IntegratedResult,
-  options?: BuildDocumentOptions,
+  options: BuildDocumentOptions,
 ): string {
   const doc = buildDocumentNode(integratedResult, options);
 
@@ -30,7 +33,7 @@ function formatDocumentNodeAsCode(
 
 export function emitTypeDefsCode(
   integratedResult: IntegratedResult,
-  options?: BuildDocumentOptions,
+  options: BuildDocumentOptions,
 ): string {
   const documentNodeCode = formatDocumentNodeAsCode(integratedResult, options);
 
@@ -42,13 +45,31 @@ export const typeDefs: DocumentNode = ${documentNodeCode} as DocumentNode;
 `;
 }
 
-function computeRelativeImportPath(fromDir: string, toFile: string): string {
+function applyExtension(
+  relativePath: string,
+  importExtension: ImportExtension,
+): string {
+  switch (importExtension) {
+    case "js":
+      return relativePath.replace(/\.ts$/, ".js");
+    case "ts":
+      return relativePath;
+    case "none":
+      return relativePath.replace(/\.ts$/, "");
+  }
+}
+
+function computeRelativeImportPath(
+  fromDir: string,
+  toFile: string,
+  importExtension: ImportExtension,
+): string {
   const relativePath = toPosixPath(path.relative(fromDir, toFile));
-  const withoutExt = relativePath.replace(/\.ts$/, ".js");
-  if (!withoutExt.startsWith(".")) {
-    return `./${withoutExt}`;
+  const withExt = applyExtension(relativePath, importExtension);
+  if (!withExt.startsWith(".")) {
+    return `./${withExt}`;
   }
-  return withoutExt;
+  return withExt;
 }
 
 interface ScalarTypeImport {
@@ -92,6 +113,7 @@ function collectScalarTypeImports(
 function buildScalarTypeImports(
   scalarTypeImports: ScalarTypeImport[],
   outputDir: string,
+  importExtension: ImportExtension,
 ): string[] {
   const importsByFile = new Map<string, string[]>();
 
@@ -106,7 +128,11 @@ function buildScalarTypeImports(
 
   for (const sourceFile of sortedFiles) {
     const typeNames = importsByFile.get(sourceFile) ?? [];
-    const importPath = computeRelativeImportPath(outputDir, sourceFile);
+    const importPath = computeRelativeImportPath(
+      outputDir,
+      sourceFile,
+      importExtension,
+    );
     imports.push(
       `import type { ${typeNames.sort().join(", ")} } from "${importPath}";`,
     );
@@ -170,13 +196,18 @@ function collectResolverImportsByFile(
 function buildResolverImports(
   importsByFile: Map<string, Set<string>>,
   outputDir: string,
+  importExtension: ImportExtension,
 ): string[] {
   const imports: string[] = [];
   const sortedFiles = [...importsByFile.keys()].sort();
 
   for (const sourceFile of sortedFiles) {
     const valueNames = importsByFile.get(sourceFile) ?? new Set<string>();
-    const importPath = computeRelativeImportPath(outputDir, sourceFile);
+    const importPath = computeRelativeImportPath(
+      outputDir,
+      sourceFile,
+      importExtension,
+    );
     const sortedValues = [...valueNames].sort();
 
     if (sortedValues.length > 0) {
@@ -248,6 +279,30 @@ function buildTypeResolverEntry(
   return `    ${type.typeName}: {\n${entries.join("\n")}\n    },`;
 }
 
+function getResolveTypeExpression(
+  fieldPattern: AutoGeneratedResolveType["fieldPattern"],
+): string {
+  const { usedFieldNames } = fieldPattern;
+
+  if (usedFieldNames.size === 1) {
+    const fieldName = [...usedFieldNames][0]!;
+    return `obj.${fieldName}`;
+  }
+
+  const expressions = TYPENAME_FIELD_NAMES.filter((name) =>
+    usedFieldNames.has(name),
+  ).map((name) => `obj.${name}`);
+
+  return expressions.join(" ?? ");
+}
+
+function buildAutoResolveTypeEntry(
+  autoResolveType: AutoGeneratedResolveType,
+): string {
+  const expression = getResolveTypeExpression(autoResolveType.fieldPattern);
+  return `    ${autoResolveType.unionTypeName}: {\n      __resolveType: (obj) => ${expression},\n    },`;
+}
+
 function buildTypeEntries(
   resolverInfo: ResolverInfo,
   customScalars: ReadonlyArray<CollectedScalarType>,
@@ -269,15 +324,21 @@ function buildTypeEntries(
     abstractResolversByType.set(abstractResolver.typeName, abstractResolver);
   }
 
+  const autoResolveTypeByUnion = new Map<string, AutoGeneratedResolveType>(
+    resolverInfo.autoGeneratedResolveTypes.map((r) => [r.unionTypeName, r]),
+  );
+
   const allTypeNames = new Set<string>([
     ...typesWithFields.keys(),
     ...abstractResolversByType.keys(),
+    ...autoResolveTypeByUnion.keys(),
   ]);
   const sortedTypeNames = [...allTypeNames].sort();
 
   for (const typeName of sortedTypeNames) {
     const typeWithFields = typesWithFields.get(typeName);
     const abstractResolver = abstractResolversByType.get(typeName) ?? null;
+    const autoResolveType = autoResolveTypeByUnion.get(typeName);
 
     if (typeWithFields !== undefined) {
       typeEntries.push(
@@ -285,6 +346,8 @@ function buildTypeEntries(
       );
     } else if (abstractResolver !== null) {
       typeEntries.push(buildAbstractOnlyTypeEntry(abstractResolver));
+    } else if (autoResolveType !== undefined) {
+      typeEntries.push(buildAutoResolveTypeEntry(autoResolveType));
     }
   }
 
@@ -297,6 +360,7 @@ interface EmitResolversCodeParams {
   readonly customScalars: ReadonlyArray<CollectedScalarType>;
   readonly numericEnums: ReadonlyArray<NumericEnumInfo>;
   readonly stringEnumMappings: ReadonlyArray<StringEnumMappingInfo>;
+  readonly importExtension: ImportExtension;
 }
 
 export function emitResolversCode(params: EmitResolversCodeParams): string {
@@ -306,6 +370,7 @@ export function emitResolversCode(params: EmitResolversCodeParams): string {
     customScalars,
     numericEnums,
     stringEnumMappings,
+    importExtension,
   } = params;
   const hasCustomScalars = customScalars.length > 0;
   const imports: string[] = [];
@@ -315,11 +380,17 @@ export function emitResolversCode(params: EmitResolversCodeParams): string {
   }
 
   const importsByFile = collectResolverImportsByFile(resolverInfo);
-  imports.push(...buildResolverImports(importsByFile, outputDir));
+  imports.push(
+    ...buildResolverImports(importsByFile, outputDir, importExtension),
+  );
 
   if (hasCustomScalars) {
     const scalarTypeImports = collectScalarTypeImports(customScalars);
-    const scalarImports = buildScalarTypeImports(scalarTypeImports, outputDir);
+    const scalarImports = buildScalarTypeImports(
+      scalarTypeImports,
+      outputDir,
+      importExtension,
+    );
     imports.push(...scalarImports);
   }
 

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

@@ -3,10 +3,6 @@ import { type DocumentNode, print } from "graphql";
 const GENERATED_FILE_HEADER =
   "# This file is auto-generated by gqlkit. DO NOT EDIT.";
 
-/**
- * DocumentNode を SDL 形式の文字列に変換する。
- * graphql パッケージの print() 関数を使用して SDL を生成する。
- */
 export function emitSdlContent(documentNode: DocumentNode): string {
   const sdl = print(documentNode);
   return `${GENERATED_FILE_HEADER}\n\n${sdl}`;

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

@@ -1,7 +1,12 @@
 import {
+  collectTypenameExtractions,
+  collectTypenameResolveTypes,
   generateAutoTypes,
   validateNameCollisions,
+  validateSchemaTypenames,
+  validateTypenames,
 } from "../auto-type-generator/index.js";
+import type { ImportExtension } from "../config/types.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";
@@ -28,6 +33,8 @@ export interface GenerateSchemaInput {
   readonly directiveDefinitions: ReadonlyArray<DirectiveDefinitionInfo> | null;
   readonly enablePruning: boolean | null;
   readonly sourceRoot: string | null;
+  readonly knownTypeNames: ReadonlySet<string> | null;
+  readonly importExtension: ImportExtension;
 }
 
 export interface GenerateSchemaResult {
@@ -52,11 +59,14 @@ export function generateSchema(
     directiveDefinitions,
     enablePruning,
     sourceRoot,
+    knownTypeNames,
+    importExtension,
   } = input;
 
   const autoTypeResult = generateAutoTypes({
     extractedTypes,
     resolversResult,
+    knownTypeNames: knownTypeNames ?? new Set(),
   });
 
   const autoTypeErrors = autoTypeResult.diagnostics.filter(
@@ -120,19 +130,106 @@ export function generateSchema(
     },
   };
 
-  const integratedResult = integrate(
-    updatedTypesResult,
-    autoTypeResult.updatedResolversResult,
-    customScalarNames,
-    customScalars,
-    directiveDefinitions,
-    autoTypeResult.autoGeneratedTypes,
+  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),
   );
 
-  let documentNode = buildDocumentNode(
-    integratedResult,
-    sourceRoot !== null ? { sourceRoot } : undefined,
+  const typenameResolveTypesResult = collectTypenameResolveTypes({
+    extractedTypes: autoTypeResult.updatedExtractedTypes,
+    typeMap,
+    manualResolveTypeNames,
+  });
+
+  const typenameExtractions = collectTypenameExtractions({
+    extractedTypes: autoTypeResult.updatedExtractedTypes,
+    typeMap,
+  });
+
+  const typenameValidationDiagnostics: Diagnostic[] = [];
+
+  for (const extraction of typenameExtractions) {
+    const abstractType = typeMap.get(extraction.abstractTypeName);
+    if (!abstractType) {
+      continue;
+    }
+    const validationResult = validateTypenames({
+      extractionResult: extraction,
+      sourceLocation: abstractType.metadata.sourceLocation,
+      inlineObjectMembers: abstractType.inlineObjectMembers,
+    });
+    typenameValidationDiagnostics.push(...validationResult.diagnostics);
+  }
+
+  const schemaTypenameValidationResult = validateSchemaTypenames({
+    objectTypes: autoTypeResult.updatedExtractedTypes,
+    typeMap,
+  });
+  typenameValidationDiagnostics.push(
+    ...schemaTypenameValidationResult.diagnostics,
   );
+
+  if (typenameValidationDiagnostics.length > 0) {
+    return {
+      typeDefsCode: "",
+      sdlContent: "",
+      resolversCode: "",
+      diagnostics: typenameValidationDiagnostics,
+      hasErrors: true,
+      prunedTypes: null,
+    };
+  }
+
+  const generatedInlineObjectTypes =
+    typenameResolveTypesResult.generatedInlineObjectTypes;
+
+  const updatedTypesForIntegration: ExtractTypesResult =
+    generatedInlineObjectTypes.length > 0
+      ? {
+          types: updatedTypesResult.types.map((type) => {
+            if (type.kind !== "Union") {
+              return type;
+            }
+            const inlineTypes = generatedInlineObjectTypes.filter(
+              (g) => g.abstractTypeName === type.name,
+            );
+            if (inlineTypes.length === 0) {
+              return type;
+            }
+            const newMembers = inlineTypes.map((g) => g.typeName);
+            return {
+              ...type,
+              unionMembers: [
+                ...(type.unionMembers ?? []),
+                ...newMembers,
+              ].sort(),
+            };
+          }),
+          diagnostics: updatedTypesResult.diagnostics,
+        }
+      : updatedTypesResult;
+
+  const allAutoGeneratedTypes = [
+    ...autoTypeResult.autoGeneratedTypes,
+    ...typenameResolveTypesResult.generatedObjectTypes,
+  ];
+
+  const integratedResult = integrate({
+    typesResult: updatedTypesForIntegration,
+    resolversResult: autoTypeResult.updatedResolversResult,
+    customScalarNames,
+    collectedScalars: customScalars,
+    directiveDefinitions,
+    autoGeneratedTypes: allAutoGeneratedTypes,
+    typenameAutoResolveTypes: typenameResolveTypesResult.autoResolveTypes,
+  });
+
+  let documentNode = buildDocumentNode(integratedResult, { sourceRoot });
   let prunedTypes: ReadonlyArray<string> | null = null;
 
   if (enablePruning) {
@@ -144,10 +241,7 @@ export function generateSchema(
     prunedTypes = pruneResult.removedTypes;
   }
 
-  const typeDefsCode = emitTypeDefsCode(
-    integratedResult,
-    sourceRoot !== null ? { sourceRoot } : undefined,
-  );
+  const typeDefsCode = emitTypeDefsCode(integratedResult, { sourceRoot });
   const sdlContent = emitSdlContent(documentNode);
 
   const resolverInfo = collectResolverInfo(integratedResult);
@@ -157,6 +251,7 @@ export function generateSchema(
     customScalars: customScalars ?? [],
     numericEnums: integratedResult.numericEnums,
     stringEnumMappings: integratedResult.stringEnumMappings,
+    importExtension,
   });
 
   return {