@gqlkit-ts/cli 0.1.0 → 0.3.0

package/dist/type-extractor/extractor/type-extractor.js

@@ -3,31 +3,17 @@ import ts from "typescript";
 import { isInternalTypeSymbol } from "../../shared/constants.js";
 import { detectDefaultValueMetadata } from "../../shared/default-value-detector.js";
 import { detectDirectiveMetadata, hasDirectiveMetadata, unwrapDirectiveType, } from "../../shared/directive-detector.js";
+import { detectIgnoreFieldsMetadata } from "../../shared/ignore-fields-detector.js";
+import { validateIgnoreFields } from "../../shared/ignore-fields-validator.js";
 import { extractInlineObjectProperties as extractInlineObjectPropertiesShared } from "../../shared/inline-object-extractor.js";
 import { isInlineObjectType } from "../../shared/inline-object-utils.js";
 import { extractImplementsFromDefineInterface, extractImplementsFromGqlTypeDef, isDefineInterfaceTypeAlias, } from "../../shared/interface-detector.js";
 import { detectScalarMetadata } from "../../shared/metadata-detector.js";
 import { getSourceLocationFromNode, } from "../../shared/source-location.js";
 import { extractTsDocFromSymbol, extractTsDocInfo, } from "../../shared/tsdoc-parser.js";
-import { extractPropertySymbols, getNonNullableTypes, hasUndefinedInType, isAnonymousObjectType, isExported, isNullableUnion, isNullOrUndefined, shouldTreatIntersectionAsInline, } from "../../shared/typescript-utils.js";
-/**
- * Finds the parent enum symbol if all types belong to the same enum.
- * Returns null if types are empty, don't have a common parent enum, or belong to different enums.
- */
-function findEnumParentSymbol(types) {
-    if (types.length === 0)
-        return null;
-    const firstSymbol = types[0].symbol;
-    const parentSymbol = firstSymbol?.parent;
-    if (!parentSymbol || !(parentSymbol.flags & ts.SymbolFlags.Enum)) {
-        return null;
-    }
-    const allBelongToSameEnum = types.every((t) => {
-        const sym = t.symbol;
-        return sym?.parent === parentSymbol;
-    });
-    return allBelongToSameEnum ? parentSymbol : null;
-}
+import { extractPropertySymbols, filterNonNullTypeNodes, findEnumParentSymbol, findNonNullTypeNode, getNonNullableTypes, getTypeNameFromNode, hasUndefinedInType, isAnonymousObjectType, isBooleanUnion, isExported, isNullableUnion, isNullOrUndefined, shouldTreatIntersectionAsInline, } from "../../shared/typescript-utils.js";
+import { createArrayType, createInlineObjectType, createLiteralType, createPrimitiveType, createReferenceType, createScalarType, createUnionType, } from "../types/index.js";
+import { resolveFieldType } from "./field-type-resolver.js";
 function isDefaultExport(node, sourceFile) {
     let hasDefaultExport = false;
     const nodeName = node.name?.getText(sourceFile);
@@ -42,50 +28,36 @@ function isDefaultExport(node, sourceFile) {
     });
     return hasDefaultExport;
 }
-function isBooleanUnion(type) {
-    if (!type.isUnion())
-        return false;
-    const nonNullTypes = getNonNullableTypes(type);
-    return (nonNullTypes.length === 2 &&
-        nonNullTypes.every((t) => t.flags & ts.TypeFlags.BooleanLiteral));
-}
 /**
  * Attempts to extract a type as an inline object, with cycle detection.
  * Returns a reference type if a cycle is detected, otherwise returns an inline object.
  */
-function tryExtractAsInlineObject(type, checker, globalTypeMappings, visitedTypes) {
+function tryExtractAsInlineObject(type, ctx) {
+    const { checker, visitedTypes } = ctx;
     if (visitedTypes.has(type)) {
         const typeName = type.symbol?.getName() ?? "Object";
         return {
-            tsType: {
-                kind: "reference",
+            tsType: createReferenceType({
                 name: typeName === "__type" ? "Object" : typeName,
-                elementType: null,
-                members: null,
                 nullable: false,
-                scalarInfo: null,
-                inlineObjectProperties: null,
-            },
+            }),
         };
     }
     visitedTypes.add(type);
-    const inlineProperties = extractInlineObjectPropertiesShared(type, checker, (t, c) => convertTsTypeToReference(t, c, globalTypeMappings, visitedTypes).tsType);
+    const inlineProperties = extractInlineObjectPropertiesShared(type, checker, (t) => convertTsTypeToReference(t, ctx).tsType);
     return {
-        tsType: {
-            kind: "inlineObject",
-            name: null,
-            elementType: null,
-            members: null,
-            nullable: false,
-            scalarInfo: null,
-            inlineObjectProperties: inlineProperties,
-        },
+        tsType: createInlineObjectType({
+            properties: inlineProperties,
+            description: null,
+            deprecated: null,
+        }),
     };
 }
 function findGlobalTypeMapping(typeName, globalTypeMappings) {
     return globalTypeMappings.find((m) => m.typeName === typeName);
 }
-function convertTsTypeToReference(type, checker, globalTypeMappings = [], visitedTypes = new WeakSet()) {
+function convertTsTypeToReference(type, ctx, typeNode) {
+    const { checker, globalTypeMappings, knownTypeNames } = ctx;
     const metadataResult = detectScalarMetadata(type, checker);
     // Skip scalar detection if it's an array of scalars (e.g., Int[])
     // Array types should be handled by the array handling logic below
@@ -93,12 +65,8 @@ function convertTsTypeToReference(type, checker, globalTypeMappings = [], visite
         !metadataResult.isPrimitive &&
         !metadataResult.isList) {
         return {
-            tsType: {
-                kind: "scalar",
+            tsType: createScalarType({
                 name: metadataResult.scalarName,
-                elementType: null,
-                members: null,
-                nullable: metadataResult.nullable,
                 scalarInfo: {
                     scalarName: metadataResult.scalarName,
                     typeName: metadataResult.scalarName,
@@ -106,22 +74,14 @@ function convertTsTypeToReference(type, checker, globalTypeMappings = [], visite
                     isCustom: true,
                     only: metadataResult.only,
                 },
-                inlineObjectProperties: null,
-            },
+                nullable: metadataResult.nullable,
+            }),
         };
     }
     if (isBooleanUnion(type)) {
         const nullable = isNullableUnion(type);
         return {
-            tsType: {
-                kind: "primitive",
-                name: "boolean",
-                elementType: null,
-                members: null,
-                nullable,
-                scalarInfo: null,
-                inlineObjectProperties: null,
-            },
+            tsType: createPrimitiveType({ name: "boolean", nullable }),
         };
     }
     if (type.isUnion()) {
@@ -131,15 +91,7 @@ function convertTsTypeToReference(type, checker, globalTypeMappings = [], visite
         if (aliasSymbol) {
             const name = aliasSymbol.getName();
             return {
-                tsType: {
-                    kind: "reference",
-                    name,
-                    elementType: null,
-                    members: null,
-                    nullable,
-                    scalarInfo: null,
-                    inlineObjectProperties: null,
-                },
+                tsType: createReferenceType({ name, nullable }),
             };
         }
         const nonNullTypes = getNonNullableTypes(type);
@@ -147,129 +99,72 @@ function convertTsTypeToReference(type, checker, globalTypeMappings = [], visite
         const enumParentSymbol = findEnumParentSymbol(nonNullTypes);
         if (enumParentSymbol) {
             return {
-                tsType: {
-                    kind: "reference",
+                tsType: createReferenceType({
                     name: enumParentSymbol.getName(),
-                    elementType: null,
-                    members: null,
                     nullable,
-                    scalarInfo: null,
-                    inlineObjectProperties: null,
-                },
+                }),
             };
         }
         if (nonNullTypes.length === 1) {
-            const innerResult = convertTsTypeToReference(nonNullTypes[0], checker, globalTypeMappings, visitedTypes);
+            // For nullable types like User | null, extract the non-null type node
+            const nonNullTypeNode = typeNode && ts.isUnionTypeNode(typeNode)
+                ? findNonNullTypeNode(typeNode)
+                : undefined;
+            const innerResult = convertTsTypeToReference(nonNullTypes[0], ctx, nonNullTypeNode);
             return {
                 tsType: { ...innerResult.tsType, nullable },
             };
         }
-        const memberResults = nonNullTypes.map((t) => convertTsTypeToReference(t, checker, globalTypeMappings, visitedTypes));
+        const memberResults = nonNullTypes.map((t) => convertTsTypeToReference(t, ctx));
         return {
-            tsType: {
-                kind: "union",
-                name: null,
-                elementType: null,
+            tsType: createUnionType({
                 members: memberResults.map((r) => r.tsType),
                 nullable,
-                scalarInfo: null,
-                inlineObjectProperties: null,
-            },
+            }),
         };
     }
     if (checker.isArrayType(type)) {
         const typeArgs = type.typeArguments;
         const elementType = typeArgs?.[0];
+        // Extract element type node from array type node (e.g., User[] -> User)
+        let elementTypeNode;
+        if (typeNode && ts.isArrayTypeNode(typeNode)) {
+            elementTypeNode = typeNode.elementType;
+        }
         const elementResult = elementType
-            ? convertTsTypeToReference(elementType, checker, globalTypeMappings, visitedTypes)
+            ? convertTsTypeToReference(elementType, ctx, elementTypeNode)
             : {
-                tsType: {
-                    kind: "primitive",
-                    name: "unknown",
-                    elementType: null,
-                    members: null,
-                    nullable: false,
-                    scalarInfo: null,
-                    inlineObjectProperties: null,
-                },
+                tsType: createPrimitiveType({ name: "unknown", nullable: false }),
             };
         return {
-            tsType: {
-                kind: "array",
-                name: null,
-                elementType: elementResult.tsType,
-                members: null,
-                nullable: false,
-                scalarInfo: null,
-                inlineObjectProperties: null,
-            },
+            tsType: createArrayType(elementResult.tsType),
         };
     }
     const typeString = checker.typeToString(type);
     if (type.flags & ts.TypeFlags.String) {
         return {
-            tsType: {
-                kind: "primitive",
-                name: "string",
-                elementType: null,
-                members: null,
-                nullable: false,
-                scalarInfo: null,
-                inlineObjectProperties: null,
-            },
+            tsType: createPrimitiveType({ name: "string", nullable: false }),
         };
     }
     if (type.flags & ts.TypeFlags.Number) {
         return {
-            tsType: {
-                kind: "primitive",
-                name: "number",
-                elementType: null,
-                members: null,
-                nullable: false,
-                scalarInfo: null,
-                inlineObjectProperties: null,
-            },
+            tsType: createPrimitiveType({ name: "number", nullable: false }),
         };
     }
     if (type.flags & ts.TypeFlags.Boolean ||
         type.flags & ts.TypeFlags.BooleanLiteral) {
         return {
-            tsType: {
-                kind: "primitive",
-                name: "boolean",
-                elementType: null,
-                members: null,
-                nullable: false,
-                scalarInfo: null,
-                inlineObjectProperties: null,
-            },
+            tsType: createPrimitiveType({ name: "boolean", nullable: false }),
         };
     }
     if (type.flags & ts.TypeFlags.StringLiteral) {
         return {
-            tsType: {
-                kind: "literal",
-                name: typeString.replace(/"/g, ""),
-                elementType: null,
-                members: null,
-                nullable: false,
-                scalarInfo: null,
-                inlineObjectProperties: null,
-            },
+            tsType: createLiteralType(typeString.replace(/"/g, "")),
         };
     }
     if (type.flags & ts.TypeFlags.NumberLiteral) {
         return {
-            tsType: {
-                kind: "literal",
-                name: typeString,
-                elementType: null,
-                members: null,
-                nullable: false,
-                scalarInfo: null,
-                inlineObjectProperties: null,
-            },
+            tsType: createLiteralType(typeString),
         };
     }
     // Handle intersection types that should be treated as inline objects
@@ -281,31 +176,43 @@ function convertTsTypeToReference(type, checker, globalTypeMappings = [], visite
         if (type.aliasSymbol) {
             const aliasName = type.aliasSymbol.getName();
             return {
-                tsType: {
-                    kind: "reference",
-                    name: aliasName,
-                    elementType: null,
-                    members: null,
-                    nullable: false,
-                    scalarInfo: null,
-                    inlineObjectProperties: null,
-                },
+                tsType: createReferenceType({ name: aliasName, nullable: false }),
             };
         }
         const shouldTreatAsInline = shouldTreatIntersectionAsInline(type);
         if (shouldTreatAsInline) {
-            return tryExtractAsInlineObject(type, checker, globalTypeMappings, visitedTypes);
+            return tryExtractAsInlineObject(type, ctx);
         }
     }
     if (isInlineObjectType(type)) {
-        return tryExtractAsInlineObject(type, checker, globalTypeMappings, visitedTypes);
+        // Check if typeNode references a known type (schema-defined type)
+        if (typeNode && ts.isTypeReferenceNode(typeNode)) {
+            const typeName = getTypeNameFromNode(typeNode);
+            if (typeName && knownTypeNames.has(typeName)) {
+                return {
+                    tsType: createReferenceType({ name: typeName, nullable: false }),
+                };
+            }
+        }
+        return tryExtractAsInlineObject(type, ctx);
     }
     // Check for utility types (Omit, Pick, Partial, Required, etc.)
     // These create mapped types that should be treated as inline objects
     if (type.flags & ts.TypeFlags.Object) {
         const objectType = type;
         if (objectType.objectFlags & ts.ObjectFlags.Mapped) {
-            return tryExtractAsInlineObject(type, checker, globalTypeMappings, visitedTypes);
+            // Check if typeNode references a known type (schema-defined type).
+            // This handles Simplify<T> = { [K in keyof T]: T[K] } & {} pattern.
+            if (typeNode && ts.isTypeReferenceNode(typeNode)) {
+                const typeName = getTypeNameFromNode(typeNode);
+                // Only use typeNode name if it's in knownTypeNames (schema-defined type)
+                if (typeName && knownTypeNames.has(typeName)) {
+                    return {
+                        tsType: createReferenceType({ name: typeName, nullable: false }),
+                    };
+                }
+            }
+            return tryExtractAsInlineObject(type, ctx);
         }
     }
     if (type.symbol) {
@@ -315,12 +222,8 @@ function convertTsTypeToReference(type, checker, globalTypeMappings = [], visite
             const globalMapping = findGlobalTypeMapping(symbolName, globalTypeMappings);
             if (globalMapping) {
                 return {
-                    tsType: {
-                        kind: "scalar",
+                    tsType: createScalarType({
                         name: globalMapping.scalarName,
-                        elementType: null,
-                        members: null,
-                        nullable: false,
                         scalarInfo: {
                             scalarName: globalMapping.scalarName,
                             typeName: globalMapping.typeName,
@@ -328,36 +231,32 @@ function convertTsTypeToReference(type, checker, globalTypeMappings = [], visite
                             isCustom: true,
                             only: globalMapping.only,
                         },
-                        inlineObjectProperties: null,
-                    },
+                        nullable: false,
+                    }),
                 };
             }
             return {
-                tsType: {
-                    kind: "reference",
-                    name: symbolName,
-                    elementType: null,
-                    members: null,
-                    nullable: false,
-                    scalarInfo: null,
-                    inlineObjectProperties: null,
-                },
+                tsType: createReferenceType({ name: symbolName, nullable: false }),
             };
         }
     }
     return {
-        tsType: {
-            kind: "reference",
-            name: typeString,
-            elementType: null,
-            members: null,
-            nullable: false,
-            scalarInfo: null,
-            inlineObjectProperties: null,
-        },
+        tsType: createReferenceType({ name: typeString, nullable: false }),
     };
 }
-function extractFieldsFromType(type, checker, globalTypeMappings = []) {
+function collectAllFieldNames(type, checker) {
+    const properties = extractPropertySymbols(type, checker);
+    const fieldNames = new Set();
+    for (const prop of properties) {
+        const propName = prop.getName();
+        if (!propName.startsWith(" $")) {
+            fieldNames.add(propName);
+        }
+    }
+    return fieldNames;
+}
+function extractFieldsFromType(params) {
+    const { type, checker, globalTypeMappings, knownTypeNames, knownTypeSymbols, underlyingSymbolToTypeName, sourceFiles, scalarMappingTable, scalarMappingContext, ignoreFields, } = params;
     const fields = [];
     const diagnostics = [];
     const properties = extractPropertySymbols(type, checker);
@@ -366,6 +265,9 @@ function extractFieldsFromType(type, checker, globalTypeMappings = []) {
         if (propName.startsWith(" $")) {
             continue;
         }
+        if (ignoreFields?.has(propName)) {
+            continue;
+        }
         const propType = checker.getTypeOfSymbol(prop);
         const declarations = prop.getDeclarations();
         const declaration = declarations?.[0];
@@ -408,11 +310,27 @@ function extractFieldsFromType(type, checker, globalTypeMappings = []) {
                 directiveNullable = true;
             }
         }
-        const typeResult = convertTsTypeToReference(actualPropType, checker, globalTypeMappings);
+        // Get typeNode from property declaration to preserve type alias names
+        let propTypeNode;
+        if (declaration &&
+            (ts.isPropertySignature(declaration) ||
+                ts.isPropertyDeclaration(declaration))) {
+            propTypeNode = declaration.type;
+        }
+        const resolvedType = resolveFieldType(actualPropType, propTypeNode, {
+            checker,
+            knownTypeNames,
+            knownTypeSymbols,
+            underlyingSymbolToTypeName,
+            globalTypeMappings,
+            sourceFiles,
+            scalarMappingTable,
+            scalarMappingContext,
+        });
         // Preserve nullability from original WithDirectives type
-        const tsType = directiveNullable && !typeResult.tsType.nullable
-            ? { ...typeResult.tsType, nullable: true }
-            : typeResult.tsType;
+        const tsType = directiveNullable && !resolvedType.nullable
+            ? { ...resolvedType, nullable: true }
+            : resolvedType;
         fields.push({
             name: propName,
             tsType,
@@ -567,12 +485,12 @@ function extractStringLiteralUnionMembers(type, checker) {
     }
     return members;
 }
-function determineTypeKind(node, type, sourceFile) {
+function determineTypeKind(node, type, checker) {
     if (ts.isInterfaceDeclaration(node)) {
         return "interface";
     }
     if (ts.isTypeAliasDeclaration(node)) {
-        if (isDefineInterfaceTypeAlias(node, sourceFile)) {
+        if (isDefineInterfaceTypeAlias(node, checker)) {
             return "graphqlInterface";
         }
         const unionKind = determineTypeKindFromUnion(type);
@@ -633,7 +551,7 @@ function createGenericTypeDiagnostic(declaration, exportedName, location) {
     return null;
 }
 function processReexportedSymbol(params) {
-    const { exportedName, resolvedSymbol, type, location, filePath, checker, globalTypeMappings, scannedSourceFiles, } = params;
+    const { exportedName, resolvedSymbol, type, location, filePath, checker, globalTypeMappings, knownTypeNames, knownTypeSymbols, underlyingSymbolToTypeName, scannedSourceFiles, scalarMappingTable, scalarMappingContext, } = params;
     const diagnostics = [];
     const scalarMetadataResult = detectScalarMetadata(type, checker);
     if (scalarMetadataResult.scalarName && !scalarMetadataResult.isPrimitive) {
@@ -710,10 +628,38 @@ function processReexportedSymbol(params) {
             skip: false,
         };
     }
-    const unionMembers = extractUnionMembers(type);
+    // Get typeNode for union member extraction from declaration
+    const reexportDeclarations = resolvedSymbol.getDeclarations();
+    const reexportDeclaration = reexportDeclarations?.[0];
+    const reexportTypeNode = reexportDeclaration && ts.isTypeAliasDeclaration(reexportDeclaration)
+        ? reexportDeclaration.type
+        : undefined;
+    const unionMembers = extractUnionMembers(type, reexportTypeNode);
+    const ignoreFields = detectIgnoreFieldsMetadata({ type, checker });
+    if (ignoreFields !== null && kind !== "union") {
+        const allFieldNames = collectAllFieldNames(type, checker);
+        const validationDiagnostics = validateIgnoreFields({
+            typeName: exportedName,
+            ignoreFields,
+            allFieldNames,
+            sourceLocation: location,
+        });
+        diagnostics.push(...validationDiagnostics);
+    }
     const fieldResult = kind === "union"
         ? { fields: [], diagnostics: [] }
-        : extractFieldsFromType(type, checker, globalTypeMappings);
+        : extractFieldsFromType({
+            type,
+            checker,
+            globalTypeMappings,
+            knownTypeNames,
+            knownTypeSymbols,
+            underlyingSymbolToTypeName,
+            sourceFiles: scannedSourceFiles,
+            scalarMappingTable,
+            scalarMappingContext,
+            ignoreFields,
+        });
     diagnostics.push(...fieldResult.diagnostics);
     return {
         typeInfo: {
@@ -730,7 +676,7 @@ function processReexportedSymbol(params) {
         skip: false,
     };
 }
-function processExportDeclaration(node, sourceFile, filePath, checker, globalTypeMappings, scannedSourceFiles) {
+function processExportDeclaration(node, sourceFile, filePath, checker, globalTypeMappings, knownTypeNames, knownTypeSymbols, underlyingSymbolToTypeName, scannedSourceFiles, scalarMappingTable) {
     const types = [];
     const diagnostics = [];
     const detectedScalarNames = [];
@@ -802,7 +748,12 @@ function processExportDeclaration(node, sourceFile, filePath, checker, globalTyp
             filePath,
             checker,
             globalTypeMappings,
+            knownTypeNames,
+            knownTypeSymbols,
+            underlyingSymbolToTypeName,
             scannedSourceFiles,
+            scalarMappingTable,
+            scalarMappingContext: exportedName.endsWith("Input") ? "input" : "output",
         });
         if (result.skip)
             continue;
@@ -826,11 +777,15 @@ function getNamedTypeName(memberType) {
     // For regular types, use symbol
     return memberType.symbol?.getName() ?? "";
 }
-function extractInlineObjectMembers(type, checker, globalTypeMappings = []) {
+function extractInlineObjectMembers(params) {
+    const { type, checker, globalTypeMappings, knownTypeNames, typeNode } = params;
     if (!type.isUnion()) {
         return null;
     }
     const nonNullTypes = getNonNullableTypes(type);
+    const memberTypeNodes = typeNode && ts.isUnionTypeNode(typeNode)
+        ? filterNonNullTypeNodes(typeNode)
+        : [];
     const allObjectTypes = nonNullTypes.every((t) => (t.flags & ts.TypeFlags.Object) !== 0 ||
         (t.flags & ts.TypeFlags.Intersection) !== 0);
     if (nonNullTypes.length < 2 || !allObjectTypes) {
@@ -839,31 +794,55 @@ function extractInlineObjectMembers(type, checker, globalTypeMappings = []) {
     let hasInlineObjects = false;
     let hasNamedTypes = false;
     const members = [];
-    for (const memberType of nonNullTypes) {
-        if (isAnonymousObjectType(memberType)) {
-            hasInlineObjects = true;
-            const properties = memberType.getProperties();
-            const memberProperties = [];
-            for (const prop of properties) {
-                const propType = checker.getTypeOfSymbol(prop);
-                const tsdocInfo = extractTsDocFromSymbol(prop, checker);
-                const typeResult = convertTsTypeToReference(propType, checker, globalTypeMappings);
-                memberProperties.push({
-                    propertyName: prop.getName(),
-                    propertyType: typeResult.tsType,
-                    description: tsdocInfo.description ?? null,
-                    deprecated: tsdocInfo.deprecated ?? null,
-                });
+    const ctx = {
+        checker,
+        globalTypeMappings,
+        knownTypeNames,
+        visitedTypes: new WeakSet(),
+    };
+    if (memberTypeNodes.length > 0) {
+        for (const memberNode of memberTypeNodes) {
+            if (ts.isTypeReferenceNode(memberNode)) {
+                hasNamedTypes = true;
+            }
+            else {
+                hasInlineObjects = true;
             }
-            members.push({ properties: memberProperties });
         }
-        else {
-            hasNamedTypes = true;
+    }
+    else {
+        for (const memberType of nonNullTypes) {
+            if (isAnonymousObjectType(memberType)) {
+                hasInlineObjects = true;
+            }
+            else {
+                hasNamedTypes = true;
+            }
+        }
+    }
+    if (hasInlineObjects) {
+        for (const memberType of nonNullTypes) {
+            if (isAnonymousObjectType(memberType)) {
+                const properties = memberType.getProperties();
+                const memberProperties = [];
+                for (const prop of properties) {
+                    const propType = checker.getTypeOfSymbol(prop);
+                    const tsdocInfo = extractTsDocFromSymbol(prop, checker);
+                    const typeResult = convertTsTypeToReference(propType, ctx);
+                    memberProperties.push({
+                        propertyName: prop.getName(),
+                        propertyType: typeResult.tsType,
+                        description: tsdocInfo.description ?? null,
+                        deprecated: tsdocInfo.deprecated ?? null,
+                    });
+                }
+                members.push({ properties: memberProperties });
+            }
         }
     }
     return { members, hasInlineObjects, hasNamedTypes };
 }
-function extractUnionMembers(type) {
+function extractUnionMembers(type, typeNode) {
     if (!type.isUnion()) {
         return undefined;
     }
@@ -872,9 +851,28 @@ function extractUnionMembers(type) {
         (t.flags & ts.TypeFlags.Intersection) !== 0 ||
         t.symbol !== undefined);
     if (nonNullTypes.length > 1 && allObjectTypes) {
+        // Extract member type nodes from union type node if available
+        const memberTypeNodes = typeNode && ts.isUnionTypeNode(typeNode)
+            ? filterNonNullTypeNodes(typeNode)
+            : [];
         const namedMembers = nonNullTypes
-            .filter((t) => !isAnonymousObjectType(t))
-            .map((t) => getNamedTypeName(t))
+            .map((t, index) => {
+            // First try to get name from type
+            if (!isAnonymousObjectType(t)) {
+                const name = getNamedTypeName(t);
+                if (name !== "" && name !== "__type") {
+                    return name;
+                }
+            }
+            // Fallback to typeNode name for Simplify<T> pattern
+            if (memberTypeNodes[index]) {
+                const memberNode = memberTypeNodes[index];
+                if (ts.isTypeReferenceNode(memberNode)) {
+                    return getTypeNameFromNode(memberNode) ?? "";
+                }
+            }
+            return "";
+        })
             .filter((name) => name !== "" && name !== "__type");
         if (namedMembers.length > 0) {
             return namedMembers.sort();
@@ -882,13 +880,13 @@ function extractUnionMembers(type) {
     }
     return undefined;
 }
-export function extractTypesFromProgram(program, sourceFiles, options = {}) {
+export function extractTypesFromProgram(program, sourceFiles, options) {
     const checker = program.getTypeChecker();
     const types = [];
     const diagnostics = [];
     const detectedScalarNames = new Set();
     const detectedScalars = [];
-    const globalTypeMappings = options.globalTypeMappings ?? [];
+    const { globalTypeMappings, knownTypeNames, knownTypeSymbols, underlyingSymbolToTypeName, scalarMappingTable, } = options;
     const scannedSourceFilesSet = new Set(sourceFiles);
     for (const filePath of sourceFiles) {
         const sourceFile = program.getSourceFile(filePath);
@@ -1009,9 +1007,19 @@ export function extractTypesFromProgram(program, sourceFiles, options = {}) {
                     }
                     actualType = type;
                 }
-                const kind = determineTypeKind(node, actualType, sourceFile);
-                const unionMembers = extractUnionMembers(actualType);
-                const inlineObjectResult = extractInlineObjectMembers(actualType, checker, globalTypeMappings);
+                const kind = determineTypeKind(node, actualType, checker);
+                // Get typeNode for union member extraction (only for type aliases)
+                const typeAliasTypeNode = ts.isTypeAliasDeclaration(node)
+                    ? node.type
+                    : undefined;
+                const unionMembers = extractUnionMembers(actualType, typeAliasTypeNode);
+                const inlineObjectResult = extractInlineObjectMembers({
+                    type: actualType,
+                    checker,
+                    globalTypeMappings,
+                    knownTypeNames,
+                    typeNode: typeAliasTypeNode,
+                });
                 const tsdocInfo = extractTsDocInfo(node, checker);
                 let implementedInterfaces = null;
                 if (ts.isTypeAliasDeclaration(node)) {
@@ -1050,9 +1058,33 @@ export function extractTypesFromProgram(program, sourceFiles, options = {}) {
                     });
                     return;
                 }
+                const ignoreFields = detectIgnoreFieldsMetadata({ type, checker });
+                if (ignoreFields !== null && kind !== "union") {
+                    const allFieldNames = collectAllFieldNames(type, checker);
+                    const validationDiagnostics = validateIgnoreFields({
+                        typeName: name,
+                        ignoreFields,
+                        allFieldNames,
+                        sourceLocation: typeSourceLocation,
+                    });
+                    diagnostics.push(...validationDiagnostics);
+                }
                 const fieldResult = kind === "union"
                     ? { fields: [], diagnostics: [] }
-                    : extractFieldsFromType(actualType, checker, globalTypeMappings);
+                    : extractFieldsFromType({
+                        type: actualType,
+                        checker,
+                        globalTypeMappings,
+                        knownTypeNames,
+                        knownTypeSymbols,
+                        underlyingSymbolToTypeName,
+                        sourceFiles: scannedSourceFilesSet,
+                        scalarMappingTable,
+                        scalarMappingContext: name.endsWith("Input")
+                            ? "input"
+                            : "output",
+                        ignoreFields,
+                    });
                 const fields = fieldResult.fields;
                 diagnostics.push(...fieldResult.diagnostics);
                 if (name.endsWith("Input") && kind === "union") {
@@ -1081,8 +1113,7 @@ export function extractTypesFromProgram(program, sourceFiles, options = {}) {
                         });
                     }
                 }
-                const inlineObjectMembers = inlineObjectResult?.hasInlineObjects &&
-                    !inlineObjectResult.hasNamedTypes
+                const inlineObjectMembers = inlineObjectResult?.hasInlineObjects
                     ? inlineObjectResult.members
                     : null;
                 const typeInfo = {
@@ -1096,7 +1127,7 @@ export function extractTypesFromProgram(program, sourceFiles, options = {}) {
                 types.push(typeInfo);
             }
             if (ts.isExportDeclaration(node)) {
-                const result = processExportDeclaration(node, sourceFile, filePath, checker, globalTypeMappings, scannedSourceFilesSet);
+                const result = processExportDeclaration(node, sourceFile, filePath, checker, globalTypeMappings, knownTypeNames, knownTypeSymbols, underlyingSymbolToTypeName, scannedSourceFilesSet, scalarMappingTable);
                 types.push(...result.types);
                 diagnostics.push(...result.diagnostics);
                 for (const scalarName of result.detectedScalarNames) {