@gqlkit-ts/cli 0.0.1 → 0.2.0

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

@@ -0,0 +1,1082 @@
+import { resolve } from "node:path";
+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 { 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, 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);
+    ts.forEachChild(sourceFile, (child) => {
+        if (ts.isExportAssignment(child) &&
+            !child.isExportEquals &&
+            ts.isIdentifier(child.expression)) {
+            if (child.expression.text === nodeName) {
+                hasDefaultExport = true;
+            }
+        }
+    });
+    return hasDefaultExport;
+}
+/**
+ * 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, ctx) {
+    const { checker, visitedTypes } = ctx;
+    if (visitedTypes.has(type)) {
+        const typeName = type.symbol?.getName() ?? "Object";
+        return {
+            tsType: createReferenceType({
+                name: typeName === "__type" ? "Object" : typeName,
+                nullable: false,
+            }),
+        };
+    }
+    visitedTypes.add(type);
+    const inlineProperties = extractInlineObjectPropertiesShared(type, checker, (t) => convertTsTypeToReference(t, ctx).tsType);
+    return {
+        tsType: createInlineObjectType(inlineProperties),
+    };
+}
+function findGlobalTypeMapping(typeName, globalTypeMappings) {
+    return globalTypeMappings.find((m) => m.typeName === typeName);
+}
+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
+    if (metadataResult.scalarName &&
+        !metadataResult.isPrimitive &&
+        !metadataResult.isList) {
+        return {
+            tsType: createScalarType({
+                name: metadataResult.scalarName,
+                scalarInfo: {
+                    scalarName: metadataResult.scalarName,
+                    typeName: metadataResult.scalarName,
+                    baseType: undefined,
+                    isCustom: true,
+                    only: metadataResult.only,
+                },
+                nullable: metadataResult.nullable,
+            }),
+        };
+    }
+    if (isBooleanUnion(type)) {
+        const nullable = isNullableUnion(type);
+        return {
+            tsType: createPrimitiveType({ name: "boolean", nullable }),
+        };
+    }
+    if (type.isUnion()) {
+        const nullable = isNullableUnion(type);
+        // Preserve type alias name for enum types (string literal unions)
+        const aliasSymbol = type.aliasSymbol;
+        if (aliasSymbol) {
+            const name = aliasSymbol.getName();
+            return {
+                tsType: createReferenceType({ name, nullable }),
+            };
+        }
+        const nonNullTypes = getNonNullableTypes(type);
+        // Check if all non-null types belong to the same enum (for numeric enums)
+        const enumParentSymbol = findEnumParentSymbol(nonNullTypes);
+        if (enumParentSymbol) {
+            return {
+                tsType: createReferenceType({
+                    name: enumParentSymbol.getName(),
+                    nullable,
+                }),
+            };
+        }
+        if (nonNullTypes.length === 1) {
+            // 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, ctx));
+        return {
+            tsType: createUnionType({
+                members: memberResults.map((r) => r.tsType),
+                nullable,
+            }),
+        };
+    }
+    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, ctx, elementTypeNode)
+            : {
+                tsType: createPrimitiveType({ name: "unknown", nullable: false }),
+            };
+        return {
+            tsType: createArrayType(elementResult.tsType),
+        };
+    }
+    const typeString = checker.typeToString(type);
+    if (type.flags & ts.TypeFlags.String) {
+        return {
+            tsType: createPrimitiveType({ name: "string", nullable: false }),
+        };
+    }
+    if (type.flags & ts.TypeFlags.Number) {
+        return {
+            tsType: createPrimitiveType({ name: "number", nullable: false }),
+        };
+    }
+    if (type.flags & ts.TypeFlags.Boolean ||
+        type.flags & ts.TypeFlags.BooleanLiteral) {
+        return {
+            tsType: createPrimitiveType({ name: "boolean", nullable: false }),
+        };
+    }
+    if (type.flags & ts.TypeFlags.StringLiteral) {
+        return {
+            tsType: createLiteralType(typeString.replace(/"/g, "")),
+        };
+    }
+    if (type.flags & ts.TypeFlags.NumberLiteral) {
+        return {
+            tsType: createLiteralType(typeString),
+        };
+    }
+    // Handle intersection types that should be treated as inline objects
+    // This includes intersections with anonymous members OR intersections of
+    // named object types (interfaces) that are not exported as GraphQL types
+    if (type.isIntersection()) {
+        // If the intersection type has an alias symbol (e.g., Comment = GqlObject<...>),
+        // treat it as a named reference to avoid infinite recursion with self-referential types
+        if (type.aliasSymbol) {
+            const aliasName = type.aliasSymbol.getName();
+            return {
+                tsType: createReferenceType({ name: aliasName, nullable: false }),
+            };
+        }
+        const shouldTreatAsInline = shouldTreatIntersectionAsInline(type);
+        if (shouldTreatAsInline) {
+            return tryExtractAsInlineObject(type, ctx);
+        }
+    }
+    if (isInlineObjectType(type)) {
+        // 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) {
+            // 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) {
+        const symbolName = type.symbol.getName();
+        // Skip internal TypeScript symbols (see constants.ts for details)
+        if (!isInternalTypeSymbol(symbolName)) {
+            const globalMapping = findGlobalTypeMapping(symbolName, globalTypeMappings);
+            if (globalMapping) {
+                return {
+                    tsType: createScalarType({
+                        name: globalMapping.scalarName,
+                        scalarInfo: {
+                            scalarName: globalMapping.scalarName,
+                            typeName: globalMapping.typeName,
+                            baseType: undefined,
+                            isCustom: true,
+                            only: globalMapping.only,
+                        },
+                        nullable: false,
+                    }),
+                };
+            }
+            return {
+                tsType: createReferenceType({ name: symbolName, nullable: false }),
+            };
+        }
+    }
+    return {
+        tsType: createReferenceType({ name: typeString, nullable: false }),
+    };
+}
+function extractFieldsFromType(params) {
+    const { type, checker, globalTypeMappings, knownTypeNames, knownTypeSymbols, underlyingSymbolToTypeName, sourceFiles, scalarMappingTable, scalarMappingContext, } = params;
+    const fields = [];
+    const diagnostics = [];
+    const properties = extractPropertySymbols(type, checker);
+    for (const prop of properties) {
+        const propName = prop.getName();
+        if (propName.startsWith(" $")) {
+            continue;
+        }
+        const propType = checker.getTypeOfSymbol(prop);
+        const declarations = prop.getDeclarations();
+        const declaration = declarations?.[0];
+        const optional = hasUndefinedInType(propType);
+        const tsdocInfo = extractTsDocFromSymbol(prop, checker);
+        let actualPropType = propType;
+        let directives = null;
+        let directiveNullable = false;
+        let defaultValue = null;
+        if (hasDirectiveMetadata(propType)) {
+            const directiveResult = detectDirectiveMetadata(propType, checker);
+            if (directiveResult.directives.length > 0) {
+                directives = directiveResult.directives;
+            }
+            // Detect default value from $gqlkitFieldMeta
+            const defaultValueResult = detectDefaultValueMetadata(propType, checker);
+            if (defaultValueResult.defaultValue) {
+                defaultValue = defaultValueResult.defaultValue;
+            }
+            if (defaultValueResult.errors.length > 0) {
+                for (const error of defaultValueResult.errors) {
+                    diagnostics.push({
+                        code: error.code,
+                        message: `Field '${propName}': ${error.message}`,
+                        severity: "warning",
+                        location: getSourceLocationFromNode(declaration),
+                    });
+                }
+            }
+            // Check if the original type is nullable before unwrapping
+            // TypeScript normalizes WithDirectives<T | null, [...]> to (T & Directive) | null
+            if (isNullableUnion(propType)) {
+                directiveNullable = true;
+            }
+            actualPropType = unwrapDirectiveType(propType, checker);
+            // Check if the unwrapped type (from $gqlkitOriginalType) is nullable
+            // This handles cases where TypeScript normalizes intersection types
+            // and loses the null from the outer union
+            if (!directiveNullable && isNullableUnion(actualPropType)) {
+                directiveNullable = true;
+            }
+        }
+        // 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 && !resolvedType.nullable
+            ? { ...resolvedType, nullable: true }
+            : resolvedType;
+        fields.push({
+            name: propName,
+            tsType,
+            optional,
+            description: tsdocInfo.description ?? null,
+            deprecated: tsdocInfo.deprecated ?? null,
+            directives,
+            defaultValue,
+            sourceLocation: getSourceLocationFromNode(declaration),
+        });
+    }
+    return { fields, diagnostics };
+}
+function isHeterogeneousEnum(node) {
+    if (!ts.isEnumDeclaration(node))
+        return false;
+    const members = node.members;
+    if (members.length <= 1)
+        return false;
+    let hasString = false;
+    let hasNumeric = false;
+    for (const member of members) {
+        const initializer = member.initializer;
+        if (initializer === undefined) {
+            hasNumeric = true;
+        }
+        else if (ts.isStringLiteral(initializer)) {
+            hasString = true;
+        }
+        else if (ts.isNumericLiteral(initializer) ||
+            ts.isPrefixUnaryExpression(initializer)) {
+            hasNumeric = true;
+        }
+        if (hasString && hasNumeric)
+            return true;
+    }
+    return false;
+}
+function isConstEnum(node) {
+    if (!ts.isEnumDeclaration(node))
+        return false;
+    const modifiers = ts.getCombinedModifierFlags(node);
+    return (modifiers & ts.ModifierFlags.Const) !== 0;
+}
+function isStringLiteralUnion(type) {
+    if (!type.isUnion())
+        return false;
+    const nonNullTypes = getNonNullableTypes(type);
+    if (nonNullTypes.length === 0)
+        return false;
+    return nonNullTypes.every((t) => t.flags & ts.TypeFlags.StringLiteral);
+}
+function getEnumMemberName(memberName) {
+    if (ts.isIdentifier(memberName) || ts.isStringLiteral(memberName)) {
+        return memberName.text;
+    }
+    return memberName.getText();
+}
+function extractEnumMembers(node, checker) {
+    const members = [];
+    for (const member of node.members) {
+        const name = getEnumMemberName(member.name);
+        const initializer = member.initializer;
+        const symbol = checker.getSymbolAtLocation(member.name);
+        const tsdocInfo = symbol
+            ? extractTsDocFromSymbol(symbol, checker)
+            : { description: undefined, deprecated: undefined };
+        if (initializer && ts.isStringLiteral(initializer)) {
+            members.push({
+                name,
+                value: initializer.text,
+                numericValue: null,
+                description: tsdocInfo.description ?? null,
+                deprecated: tsdocInfo.deprecated ?? null,
+                sourceLocation: getSourceLocationFromNode(member),
+            });
+        }
+        else {
+            const constantValue = checker.getConstantValue(member);
+            if (typeof constantValue === "number") {
+                members.push({
+                    name,
+                    value: name,
+                    numericValue: constantValue,
+                    description: tsdocInfo.description ?? null,
+                    deprecated: tsdocInfo.deprecated ?? null,
+                    sourceLocation: getSourceLocationFromNode(member),
+                });
+            }
+        }
+    }
+    return members;
+}
+const GRAPHQL_NAME_REGEX = /^[_A-Za-z][_0-9A-Za-z]*$/;
+function isValidGraphQLName(name) {
+    return GRAPHQL_NAME_REGEX.test(name);
+}
+function validateNumericEnumMembers(members, enumName, enumLocation) {
+    const diagnostics = [];
+    const numericMembers = members.filter((m) => m.numericValue !== null);
+    if (numericMembers.length === 0) {
+        return diagnostics;
+    }
+    const valueToMembers = new Map();
+    for (const member of numericMembers) {
+        const value = member.numericValue;
+        const existing = valueToMembers.get(value) ?? [];
+        existing.push(member.name);
+        valueToMembers.set(value, existing);
+    }
+    for (const [value, memberNames] of valueToMembers) {
+        if (memberNames.length > 1) {
+            diagnostics.push({
+                code: "DUPLICATE_ENUM_VALUE",
+                message: `Enum '${enumName}' has duplicate numeric value ${value} (used by ${memberNames.join(" and ")})`,
+                severity: "error",
+                location: enumLocation,
+            });
+        }
+    }
+    for (const member of members) {
+        if (!isValidGraphQLName(member.name)) {
+            diagnostics.push({
+                code: "INVALID_ENUM_MEMBER_NAME",
+                message: `Enum member '${enumName}.${member.name}' is not a valid GraphQL identifier`,
+                severity: "error",
+                location: member.sourceLocation ?? enumLocation,
+            });
+        }
+    }
+    return diagnostics;
+}
+function extractStringLiteralUnionMembers(type, checker) {
+    if (!type.isUnion())
+        return [];
+    const members = [];
+    for (const t of type.types) {
+        if (isNullOrUndefined(t)) {
+            continue;
+        }
+        if (t.flags & ts.TypeFlags.StringLiteral) {
+            const value = checker.typeToString(t).replace(/^"|"$/g, "");
+            members.push({
+                name: value,
+                value: value,
+                numericValue: null,
+                description: null,
+                deprecated: null,
+                sourceLocation: null,
+            });
+        }
+    }
+    return members;
+}
+function determineTypeKind(node, type, checker) {
+    if (ts.isInterfaceDeclaration(node)) {
+        return "interface";
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+        if (isDefineInterfaceTypeAlias(node, checker)) {
+            return "graphqlInterface";
+        }
+        const unionKind = determineTypeKindFromUnion(type);
+        if (unionKind) {
+            return unionKind;
+        }
+        return "object";
+    }
+    return "object";
+}
+function determineTypeKindFromUnion(type) {
+    if (!type.isUnion()) {
+        return null;
+    }
+    const nonNullTypes = getNonNullableTypes(type);
+    if (isStringLiteralUnion(type)) {
+        return "enum";
+    }
+    const allObjectTypes = nonNullTypes.every((t) => (t.flags & ts.TypeFlags.Object) !== 0 ||
+        (t.flags & ts.TypeFlags.Intersection) !== 0 ||
+        t.symbol !== undefined);
+    if (nonNullTypes.length > 1 && allObjectTypes) {
+        return "union";
+    }
+    return null;
+}
+function determineTypeKindFromType(type, originalSymbol) {
+    const declarations = originalSymbol.getDeclarations();
+    const declaration = declarations?.[0];
+    if (declaration && ts.isInterfaceDeclaration(declaration)) {
+        return "interface";
+    }
+    if (declaration && ts.isEnumDeclaration(declaration)) {
+        return "enum";
+    }
+    const unionKind = determineTypeKindFromUnion(type);
+    if (unionKind) {
+        return unionKind;
+    }
+    return "object";
+}
+function isDeclarationInScannedFiles(declaration, scannedSourceFiles) {
+    const declSourceFileName = resolve(declaration.getSourceFile().fileName);
+    return Array.from(scannedSourceFiles).some((sf) => resolve(sf) === declSourceFileName);
+}
+function createGenericTypeDiagnostic(declaration, exportedName, location) {
+    if ((ts.isTypeAliasDeclaration(declaration) ||
+        ts.isInterfaceDeclaration(declaration)) &&
+        declaration.typeParameters &&
+        declaration.typeParameters.length > 0) {
+        return {
+            code: "UNSUPPORTED_SYNTAX",
+            message: `Generic type '${exportedName}' is not supported. Consider using a concrete type instead.`,
+            severity: "warning",
+            location,
+        };
+    }
+    return null;
+}
+function processReexportedSymbol(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) {
+        const tsdocInfo = extractTsDocFromSymbol(resolvedSymbol, checker);
+        return {
+            typeInfo: null,
+            diagnostics: [],
+            scalarName: scalarMetadataResult.scalarName,
+            scalarMetadata: {
+                scalarName: scalarMetadataResult.scalarName,
+                typeName: exportedName,
+                only: scalarMetadataResult.only,
+                sourceFile: filePath,
+                line: location.line,
+                description: tsdocInfo.description ?? null,
+            },
+            skip: false,
+        };
+    }
+    const declarations = resolvedSymbol.getDeclarations();
+    const declaration = declarations?.[0];
+    if (declaration) {
+        if (isDeclarationInScannedFiles(declaration, scannedSourceFiles) &&
+            (ts.isTypeAliasDeclaration(declaration) ||
+                ts.isInterfaceDeclaration(declaration) ||
+                ts.isEnumDeclaration(declaration))) {
+            return {
+                typeInfo: null,
+                diagnostics: [],
+                scalarName: null,
+                scalarMetadata: null,
+                skip: true,
+            };
+        }
+        const genericDiagnostic = createGenericTypeDiagnostic(declaration, exportedName, location);
+        if (genericDiagnostic) {
+            diagnostics.push(genericDiagnostic);
+        }
+    }
+    const kind = determineTypeKindFromType(type, resolvedSymbol);
+    const tsdocInfo = extractTsDocFromSymbol(resolvedSymbol, checker);
+    const metadata = {
+        name: exportedName,
+        kind,
+        sourceFile: filePath,
+        sourceLocation: location,
+        exportKind: "named",
+        description: tsdocInfo.description ?? null,
+        deprecated: tsdocInfo.deprecated ?? null,
+        directives: null,
+    };
+    if (kind === "enum") {
+        const declarations = resolvedSymbol.getDeclarations();
+        const declaration = declarations?.[0];
+        let enumMembers;
+        if (declaration && ts.isEnumDeclaration(declaration)) {
+            enumMembers = extractEnumMembers(declaration, checker);
+        }
+        else {
+            enumMembers = extractStringLiteralUnionMembers(type, checker);
+        }
+        return {
+            typeInfo: {
+                metadata,
+                fields: [],
+                unionMembers: null,
+                inlineObjectMembers: null,
+                enumMembers,
+                implementedInterfaces: null,
+            },
+            diagnostics,
+            scalarName: null,
+            scalarMetadata: null,
+            skip: false,
+        };
+    }
+    // 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 fieldResult = kind === "union"
+        ? { fields: [], diagnostics: [] }
+        : extractFieldsFromType({
+            type,
+            checker,
+            globalTypeMappings,
+            knownTypeNames,
+            knownTypeSymbols,
+            underlyingSymbolToTypeName,
+            sourceFiles: scannedSourceFiles,
+            scalarMappingTable,
+            scalarMappingContext,
+        });
+    diagnostics.push(...fieldResult.diagnostics);
+    return {
+        typeInfo: {
+            metadata,
+            fields: fieldResult.fields,
+            unionMembers: unionMembers ?? null,
+            inlineObjectMembers: null,
+            enumMembers: null,
+            implementedInterfaces: null,
+        },
+        diagnostics,
+        scalarName: null,
+        scalarMetadata: null,
+        skip: false,
+    };
+}
+function processExportDeclaration(node, sourceFile, filePath, checker, globalTypeMappings, knownTypeNames, knownTypeSymbols, underlyingSymbolToTypeName, scannedSourceFiles, scalarMappingTable) {
+    const types = [];
+    const diagnostics = [];
+    const detectedScalarNames = [];
+    const detectedScalars = [];
+    if (!node.isTypeOnly) {
+        return { types, diagnostics, detectedScalarNames, detectedScalars };
+    }
+    const exportClause = node.exportClause;
+    const symbolsToProcess = [];
+    if (exportClause && ts.isNamedExports(exportClause)) {
+        for (const specifier of exportClause.elements) {
+            const exportedName = specifier.name.text;
+            const localTargetSymbol = checker.getExportSpecifierLocalTargetSymbol(specifier);
+            if (!localTargetSymbol)
+                continue;
+            const originalSymbol = localTargetSymbol.flags & ts.SymbolFlags.Alias
+                ? checker.getAliasedSymbol(localTargetSymbol)
+                : localTargetSymbol;
+            if (!originalSymbol)
+                continue;
+            const type = checker.getDeclaredTypeOfSymbol(originalSymbol);
+            symbolsToProcess.push({
+                exportedName,
+                resolvedSymbol: originalSymbol,
+                type,
+            });
+        }
+    }
+    else if (!exportClause && node.moduleSpecifier) {
+        const moduleSymbol = checker.getSymbolAtLocation(node.moduleSpecifier);
+        if (!moduleSymbol) {
+            const location = getSourceLocationFromNode(node);
+            const modulePath = ts.isStringLiteral(node.moduleSpecifier)
+                ? node.moduleSpecifier.text
+                : node.moduleSpecifier.getText(sourceFile);
+            diagnostics.push({
+                code: "MODULE_RESOLUTION_ERROR",
+                message: `Could not resolve module '${modulePath}'`,
+                severity: "error",
+                location,
+            });
+            return { types, diagnostics, detectedScalarNames, detectedScalars };
+        }
+        const exports = checker.getExportsOfModule(moduleSymbol);
+        for (const exportedSymbol of exports) {
+            const resolvedSymbol = exportedSymbol.flags & ts.SymbolFlags.Alias
+                ? checker.getAliasedSymbol(exportedSymbol)
+                : exportedSymbol;
+            if (!(resolvedSymbol.flags & ts.SymbolFlags.TypeAlias ||
+                resolvedSymbol.flags & ts.SymbolFlags.Interface ||
+                resolvedSymbol.flags & ts.SymbolFlags.Enum)) {
+                continue;
+            }
+            const type = checker.getDeclaredTypeOfSymbol(resolvedSymbol);
+            symbolsToProcess.push({
+                exportedName: exportedSymbol.getName(),
+                resolvedSymbol,
+                type,
+            });
+        }
+    }
+    const location = getSourceLocationFromNode(node);
+    for (const { exportedName, resolvedSymbol, type } of symbolsToProcess) {
+        const result = processReexportedSymbol({
+            exportedName,
+            resolvedSymbol,
+            type,
+            location,
+            filePath,
+            checker,
+            globalTypeMappings,
+            knownTypeNames,
+            knownTypeSymbols,
+            underlyingSymbolToTypeName,
+            scannedSourceFiles,
+            scalarMappingTable,
+            scalarMappingContext: exportedName.endsWith("Input") ? "input" : "output",
+        });
+        if (result.skip)
+            continue;
+        if (result.scalarName && result.scalarMetadata) {
+            detectedScalarNames.push(result.scalarName);
+            detectedScalars.push(result.scalarMetadata);
+            continue;
+        }
+        diagnostics.push(...result.diagnostics);
+        if (result.typeInfo) {
+            types.push(result.typeInfo);
+        }
+    }
+    return { types, diagnostics, detectedScalarNames, detectedScalars };
+}
+function getNamedTypeName(memberType) {
+    // For type aliases (e.g., GqlObject<...>), use aliasSymbol
+    if (memberType.aliasSymbol) {
+        return memberType.aliasSymbol.getName();
+    }
+    // For regular types, use symbol
+    return memberType.symbol?.getName() ?? "";
+}
+function extractInlineObjectMembers(params) {
+    const { type, checker, globalTypeMappings, knownTypeNames } = params;
+    if (!type.isUnion()) {
+        return null;
+    }
+    const nonNullTypes = getNonNullableTypes(type);
+    const allObjectTypes = nonNullTypes.every((t) => (t.flags & ts.TypeFlags.Object) !== 0 ||
+        (t.flags & ts.TypeFlags.Intersection) !== 0);
+    if (nonNullTypes.length < 2 || !allObjectTypes) {
+        return null;
+    }
+    let hasInlineObjects = false;
+    let hasNamedTypes = false;
+    const members = [];
+    const ctx = {
+        checker,
+        globalTypeMappings,
+        knownTypeNames,
+        visitedTypes: new WeakSet(),
+    };
+    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, ctx);
+                memberProperties.push({
+                    propertyName: prop.getName(),
+                    propertyType: typeResult.tsType,
+                    description: tsdocInfo.description ?? null,
+                    deprecated: tsdocInfo.deprecated ?? null,
+                });
+            }
+            members.push({ properties: memberProperties });
+        }
+        else {
+            hasNamedTypes = true;
+        }
+    }
+    return { members, hasInlineObjects, hasNamedTypes };
+}
+function extractUnionMembers(type, typeNode) {
+    if (!type.isUnion()) {
+        return undefined;
+    }
+    const nonNullTypes = getNonNullableTypes(type);
+    const allObjectTypes = nonNullTypes.every((t) => (t.flags & ts.TypeFlags.Object) !== 0 ||
+        (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
+            .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();
+        }
+    }
+    return undefined;
+}
+export function extractTypesFromProgram(program, sourceFiles, options) {
+    const checker = program.getTypeChecker();
+    const types = [];
+    const diagnostics = [];
+    const detectedScalarNames = new Set();
+    const detectedScalars = [];
+    const { globalTypeMappings, knownTypeNames, knownTypeSymbols, underlyingSymbolToTypeName, scalarMappingTable, } = options;
+    const scannedSourceFilesSet = new Set(sourceFiles);
+    for (const filePath of sourceFiles) {
+        const sourceFile = program.getSourceFile(filePath);
+        if (!sourceFile) {
+            diagnostics.push({
+                code: "PARSE_ERROR",
+                message: `Could not load source file: ${filePath}`,
+                severity: "error",
+                location: { file: filePath, line: 1, column: 1 },
+            });
+            continue;
+        }
+        ts.forEachChild(sourceFile, (node) => {
+            if (ts.isEnumDeclaration(node)) {
+                const hasExport = isExported(node);
+                const hasDefaultExport = isDefaultExport(node, sourceFile);
+                if (!hasExport && !hasDefaultExport) {
+                    return;
+                }
+                const name = node.name.getText(sourceFile);
+                const location = getSourceLocationFromNode(node);
+                if (isConstEnum(node)) {
+                    diagnostics.push({
+                        code: "UNSUPPORTED_ENUM_TYPE",
+                        message: `Const enum '${name}' is not supported. Use a regular enum instead.`,
+                        severity: "error",
+                        location,
+                    });
+                    return;
+                }
+                if (isHeterogeneousEnum(node)) {
+                    diagnostics.push({
+                        code: "UNSUPPORTED_ENUM_TYPE",
+                        message: `Heterogeneous enum '${name}' is not supported. Use a string enum instead.`,
+                        severity: "error",
+                        location,
+                    });
+                    return;
+                }
+                const enumMembers = extractEnumMembers(node, checker);
+                const validationDiagnostics = validateNumericEnumMembers(enumMembers, name, location);
+                if (validationDiagnostics.length > 0) {
+                    diagnostics.push(...validationDiagnostics);
+                    return;
+                }
+                const tsdocInfo = extractTsDocInfo(node, checker);
+                const metadata = {
+                    name,
+                    kind: "enum",
+                    sourceFile: filePath,
+                    sourceLocation: location,
+                    exportKind: hasDefaultExport ? "default" : "named",
+                    description: tsdocInfo.description,
+                    deprecated: tsdocInfo.deprecated,
+                    directives: null,
+                };
+                types.push({
+                    metadata,
+                    fields: [],
+                    unionMembers: null,
+                    inlineObjectMembers: null,
+                    enumMembers,
+                    implementedInterfaces: null,
+                });
+                return;
+            }
+            if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
+                const hasExport = isExported(node);
+                const hasDefaultExport = isDefaultExport(node, sourceFile);
+                if (!hasExport && !hasDefaultExport) {
+                    return;
+                }
+                const name = node.name.getText(sourceFile);
+                const typeSourceLocation = getSourceLocationFromNode(node);
+                if (node.typeParameters && node.typeParameters.length > 0) {
+                    diagnostics.push({
+                        code: "UNSUPPORTED_SYNTAX",
+                        message: `Generic type '${name}' is not supported. Consider using a concrete type instead.`,
+                        severity: "warning",
+                        location: typeSourceLocation,
+                    });
+                }
+                const symbol = checker.getSymbolAtLocation(node.name);
+                if (!symbol) {
+                    return;
+                }
+                const type = checker.getDeclaredTypeOfSymbol(symbol);
+                const scalarMetadata = detectScalarMetadata(type, checker);
+                if (scalarMetadata.scalarName && !scalarMetadata.isPrimitive) {
+                    detectedScalarNames.add(scalarMetadata.scalarName);
+                    const tsdocInfo = extractTsDocInfo(node, checker);
+                    detectedScalars.push({
+                        scalarName: scalarMetadata.scalarName,
+                        typeName: name,
+                        only: scalarMetadata.only,
+                        sourceFile: filePath,
+                        line: typeSourceLocation.line,
+                        description: tsdocInfo.description ?? null,
+                    });
+                    return;
+                }
+                let typeDirectives = null;
+                let actualType = type;
+                if (hasDirectiveMetadata(type)) {
+                    const directiveResult = detectDirectiveMetadata(type, checker);
+                    if (directiveResult.directives.length > 0) {
+                        typeDirectives = directiveResult.directives;
+                    }
+                    if (directiveResult.errors.length > 0) {
+                        for (const error of directiveResult.errors) {
+                            diagnostics.push({
+                                code: error.code,
+                                message: `Type '${name}': ${error.message}`,
+                                severity: "error",
+                                location: typeSourceLocation,
+                            });
+                        }
+                    }
+                    actualType = type;
+                }
+                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,
+                });
+                const tsdocInfo = extractTsDocInfo(node, checker);
+                let implementedInterfaces = null;
+                if (ts.isTypeAliasDeclaration(node)) {
+                    if (kind === "graphqlInterface") {
+                        const interfaces = extractImplementsFromDefineInterface(node, sourceFile, checker);
+                        if (interfaces.length > 0) {
+                            implementedInterfaces = interfaces;
+                        }
+                    }
+                    else {
+                        const interfaces = extractImplementsFromGqlTypeDef(node, sourceFile, checker);
+                        if (interfaces.length > 0) {
+                            implementedInterfaces = interfaces;
+                        }
+                    }
+                }
+                const metadata = {
+                    name,
+                    kind,
+                    sourceFile: filePath,
+                    sourceLocation: typeSourceLocation,
+                    exportKind: hasDefaultExport ? "default" : "named",
+                    description: tsdocInfo.description,
+                    deprecated: tsdocInfo.deprecated,
+                    directives: typeDirectives,
+                };
+                if (kind === "enum") {
+                    const enumMembers = extractStringLiteralUnionMembers(actualType, checker);
+                    types.push({
+                        metadata,
+                        fields: [],
+                        unionMembers: null,
+                        inlineObjectMembers: null,
+                        enumMembers,
+                        implementedInterfaces: null,
+                    });
+                    return;
+                }
+                const fieldResult = kind === "union"
+                    ? { fields: [], diagnostics: [] }
+                    : extractFieldsFromType({
+                        type: actualType,
+                        checker,
+                        globalTypeMappings,
+                        knownTypeNames,
+                        knownTypeSymbols,
+                        underlyingSymbolToTypeName,
+                        sourceFiles: scannedSourceFilesSet,
+                        scalarMappingTable,
+                        scalarMappingContext: name.endsWith("Input")
+                            ? "input"
+                            : "output",
+                    });
+                const fields = fieldResult.fields;
+                diagnostics.push(...fieldResult.diagnostics);
+                if (name.endsWith("Input") && kind === "union") {
+                    if (inlineObjectResult?.hasInlineObjects &&
+                        inlineObjectResult.hasNamedTypes) {
+                        diagnostics.push({
+                            code: "ONEOF_MIXED_MEMBERS",
+                            message: `Input union type '${name}' mixes inline object literals with named type references. Use only inline object literals for oneOf input types.`,
+                            severity: "error",
+                            location: {
+                                ...typeSourceLocation,
+                                column: 1,
+                            },
+                        });
+                    }
+                    else if (inlineObjectResult?.hasNamedTypes &&
+                        !inlineObjectResult.hasInlineObjects) {
+                        diagnostics.push({
+                            code: "ONEOF_NAMED_TYPE_UNION",
+                            message: `Input union type '${name}' uses named type references instead of inline object literals. Use inline object pattern: type ${name} = { field1: Type1 } | { field2: Type2 }`,
+                            severity: "error",
+                            location: {
+                                ...typeSourceLocation,
+                                column: 1,
+                            },
+                        });
+                    }
+                }
+                const inlineObjectMembers = inlineObjectResult?.hasInlineObjects &&
+                    !inlineObjectResult.hasNamedTypes
+                    ? inlineObjectResult.members
+                    : null;
+                const typeInfo = {
+                    metadata,
+                    fields,
+                    unionMembers: unionMembers ?? null,
+                    inlineObjectMembers,
+                    enumMembers: null,
+                    implementedInterfaces,
+                };
+                types.push(typeInfo);
+            }
+            if (ts.isExportDeclaration(node)) {
+                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) {
+                    detectedScalarNames.add(scalarName);
+                }
+                detectedScalars.push(...result.detectedScalars);
+            }
+        });
+    }
+    return {
+        types,
+        diagnostics,
+        detectedScalarNames: [...detectedScalarNames],
+        detectedScalars,
+    };
+}
+//# sourceMappingURL=type-extractor.js.map