@gqlkit-ts/cli 0.2.0 → 0.4.0

package/src/shared/ignore-fields-validator.ts

@@ -0,0 +1,66 @@
+/**
+ * IgnoreFields validator.
+ *
+ * This module provides validation functions for ignoreFields metadata,
+ * checking that specified field names exist in the type and that not
+ * all fields are excluded.
+ */
+
+import type {
+  Diagnostic,
+  SourceLocation,
+} from "../type-extractor/types/diagnostics.js";
+
+/**
+ * Parameters for validateIgnoreFields function.
+ */
+export interface ValidateIgnoreFieldsParams {
+  readonly typeName: string;
+  readonly ignoreFields: ReadonlySet<string>;
+  readonly allFieldNames: ReadonlySet<string>;
+  readonly sourceLocation: SourceLocation;
+}
+
+/**
+ * Validates ignoreFields metadata.
+ *
+ * This function checks:
+ * 1. All field names in ignoreFields exist in the type
+ * 2. Not all fields are excluded (at least one field must remain)
+ *
+ * @param params - The validation parameters
+ * @returns Array of diagnostics (empty if valid)
+ */
+export function validateIgnoreFields(
+  params: ValidateIgnoreFieldsParams,
+): ReadonlyArray<Diagnostic> {
+  const { typeName, ignoreFields, allFieldNames, sourceLocation } = params;
+  const diagnostics: Diagnostic[] = [];
+
+  for (const fieldName of ignoreFields) {
+    if (!allFieldNames.has(fieldName)) {
+      const availableFields = [...allFieldNames].sort().join(", ");
+      diagnostics.push({
+        code: "IGNORE_FIELD_NOT_FOUND",
+        message: `Type '${typeName}': ignoreFields contains unknown field '${fieldName}'. Available fields: ${availableFields}`,
+        severity: "error",
+        location: sourceLocation,
+      });
+    }
+  }
+
+  const remainingFieldCount = [...allFieldNames].filter(
+    (f) => !ignoreFields.has(f),
+  ).length;
+
+  if (remainingFieldCount === 0 && allFieldNames.size > 0) {
+    diagnostics.push({
+      code: "IGNORE_ALL_FIELDS",
+      message: `Type '${typeName}': ignoreFields excludes all fields. At least one field must remain.`,
+      severity: "error",
+      location: sourceLocation,
+    });
+  }
+
+  return diagnostics;
+}

package/src/shared/index.ts

@@ -26,6 +26,8 @@ export {
   type ScanResult,
   scanDirectory,
 } from "./file-scanner.js";
+export type { DetectIgnoreFieldsParams } from "./ignore-fields-detector.js";
+export type { ValidateIgnoreFieldsParams } from "./ignore-fields-validator.js";
 export type { TypeConverter } from "./inline-object-extractor.js";
 export { toPosixPath } from "./path-utils.js";
 export type { SourceLocation } from "./source-location.js";

package/src/shared/source-location.ts

@@ -25,3 +25,14 @@ export function getSourceLocationFromNode(
     column: character + 1,
   };
 }
+
+/**
+ * Returns the source location if present, otherwise creates a default location
+ * with the given source file and line/column 1.
+ */
+export function getSourceLocationOrDefault(
+  location: SourceLocation | null,
+  sourceFile: string,
+): SourceLocation {
+  return location ?? { file: sourceFile, line: 1, column: 1 };
+}

package/src/shared/string-utils.ts

@@ -0,0 +1,7 @@
+export function toScreamingSnakeCase(value: string): string {
+  return value
+    .replace(/[-\s]+/g, "_")
+    .replace(/([a-z])([A-Z])/g, "$1_$2")
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
+    .toUpperCase();
+}

package/src/type-extractor/converter/field-eligibility.ts

@@ -24,45 +24,29 @@ function isReservedName(name: string): boolean {
   return name.startsWith("__");
 }
 
-/**
- * Check if a field name is eligible to be included as a GraphQL object field.
- */
-export function isEligibleAsObjectField(fieldName: string): EligibilityResult {
-  if (isReservedName(fieldName)) {
-    return {
-      eligible: false,
-      skipReason: {
-        code: "RESERVED_NAME",
-        message: `Field '${fieldName}' starts with '__' which is reserved for GraphQL introspection`,
-      },
-    };
-  }
+export type FieldEligibilityKind = "object" | "input";
 
-  if (!isValidGraphQLName(fieldName)) {
-    return {
-      eligible: false,
-      skipReason: {
-        code: "INVALID_NAME",
-        message: `Field '${fieldName}' is not a valid GraphQL identifier (must match /^[_A-Za-z][_0-9A-Za-z]*$/)`,
-      },
-    };
-  }
-
-  return { eligible: true, skipReason: null };
+export interface IsEligibleFieldParams {
+  readonly fieldName: string;
+  readonly kind: FieldEligibilityKind;
 }
 
 /**
- * Check if a field name is eligible to be included as a GraphQL input object field.
+ * Check if a field name is eligible to be included as a GraphQL field.
+ * Uses the kind parameter to determine the error message prefix.
  */
-export function isEligibleAsInputObjectField(
-  fieldName: string,
+export function isEligibleField(
+  params: IsEligibleFieldParams,
 ): EligibilityResult {
+  const { fieldName, kind } = params;
+  const prefix = kind === "input" ? "Input field" : "Field";
+
   if (isReservedName(fieldName)) {
     return {
       eligible: false,
       skipReason: {
         code: "RESERVED_NAME",
-        message: `Input field '${fieldName}' starts with '__' which is reserved for GraphQL introspection`,
+        message: `${prefix} '${fieldName}' starts with '__' which is reserved for GraphQL introspection`,
       },
     };
   }
@@ -72,7 +56,7 @@ export function isEligibleAsInputObjectField(
       eligible: false,
       skipReason: {
         code: "INVALID_NAME",
-        message: `Input field '${fieldName}' is not a valid GraphQL identifier (must match /^[_A-Za-z][_0-9A-Za-z]*$/)`,
+        message: `${prefix} '${fieldName}' is not a valid GraphQL identifier (must match /^[_A-Za-z][_0-9A-Za-z]*$/)`,
       },
     };
   }

package/src/type-extractor/converter/graphql-converter.ts

@@ -3,6 +3,11 @@ import {
   isBuiltInScalar,
   PRIMITIVE_TYPE_MAP,
 } from "../../shared/constants.js";
+import {
+  detectEnumPrefix,
+  stripEnumPrefix,
+} from "../../shared/enum-prefix-detector.js";
+import { toScreamingSnakeCase } from "../../shared/string-utils.js";
 import { convertTsTypeToGraphQLType } from "../../shared/type-converter.js";
 import type {
   Diagnostic,
@@ -15,11 +20,7 @@ import type {
   InlineObjectProperty,
   SourceLocation,
 } from "../types/index.js";
-import {
-  isEligibleAsEnumValue,
-  isEligibleAsInputObjectField,
-  isEligibleAsObjectField,
-} from "./field-eligibility.js";
+import { isEligibleAsEnumValue, isEligibleField } from "./field-eligibility.js";
 
 export interface ConversionResult {
   readonly types: ReadonlyArray<GraphQLTypeInfo>;
@@ -37,14 +38,6 @@ function isInputTypeName(name: string): boolean {
   return name.endsWith("Input");
 }
 
-function toScreamingSnakeCase(value: string): string {
-  return value
-    .replace(/[-\s]+/g, "_")
-    .replace(/([a-z])([A-Z])/g, "$1_$2")
-    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
-    .toUpperCase();
-}
-
 interface ConvertEnumMembersParams {
   readonly members: ReadonlyArray<EnumMemberInfo>;
   readonly enumName: string;
@@ -60,6 +53,11 @@ interface ConvertEnumMembersResult {
   readonly hasError: boolean;
 }
 
+interface ConvertedMemberInfo {
+  readonly convertedName: string;
+  readonly member: EnumMemberInfo;
+}
+
 function convertEnumMembers(
   params: ConvertEnumMembersParams,
 ): ConvertEnumMembersResult {
@@ -69,7 +67,7 @@ function convertEnumMembers(
   let isNumeric = false;
   let needsMapping = false;
 
-  const convertedNameToOriginals = new Map<string, string[]>();
+  const eligibleMembers: ConvertedMemberInfo[] = [];
 
   for (const member of members) {
     const convertedName = toScreamingSnakeCase(member.name);
@@ -93,16 +91,31 @@ function convertEnumMembers(
       isNumeric = true;
     }
 
-    if (convertedName !== member.value) {
+    eligibleMembers.push({ convertedName, member });
+  }
+
+  const prefixDetectionResult = detectEnumPrefix({
+    enumName,
+    memberValues: eligibleMembers.map((m) => m.convertedName),
+  });
+
+  const finalNameToOriginals = new Map<string, string[]>();
+
+  for (const { convertedName, member } of eligibleMembers) {
+    let finalName = convertedName;
+    if (prefixDetectionResult.shouldStrip && prefixDetectionResult.prefix) {
+      finalName = stripEnumPrefix(convertedName, prefixDetectionResult.prefix);
+      needsMapping = true;
+    } else if (convertedName !== member.value) {
       needsMapping = true;
     }
 
-    const existingOriginals = convertedNameToOriginals.get(convertedName) ?? [];
+    const existingOriginals = finalNameToOriginals.get(finalName) ?? [];
     existingOriginals.push(member.value);
-    convertedNameToOriginals.set(convertedName, existingOriginals);
+    finalNameToOriginals.set(finalName, existingOriginals);
 
     values.push({
-      name: convertedName,
+      name: finalName,
       originalValue: member.value,
       numericValue: member.numericValue,
       description: member.description,
@@ -111,11 +124,11 @@ function convertEnumMembers(
   }
 
   let hasError = false;
-  for (const [convertedName, originals] of convertedNameToOriginals) {
+  for (const [finalName, originals] of finalNameToOriginals) {
     if (originals.length > 1) {
       diagnostics.push({
         code: "DUPLICATE_ENUM_VALUE_AFTER_CONVERSION",
-        message: `Enum '${enumName}' has duplicate value '${convertedName}' after conversion (from '${originals.join("' and '")}')`,
+        message: `Enum '${enumName}' has duplicate value '${finalName}' after conversion (from '${originals.join("' and '")}')`,
         severity: "error",
         location: enumLocation,
       });
@@ -139,9 +152,10 @@ function convertFields(
   const diagnostics: Diagnostic[] = [];
 
   for (const field of extracted.fields) {
-    const eligibility = isInput
-      ? isEligibleAsInputObjectField(field.name)
-      : isEligibleAsObjectField(field.name);
+    const eligibility = isEligibleField({
+      fieldName: field.name,
+      kind: isInput ? "input" : "object",
+    });
 
     if (!eligibility.eligible) {
       diagnostics.push({

package/src/type-extractor/extractor/field-type-resolver.ts

@@ -1,4 +1,8 @@
 import ts from "typescript";
+import {
+  detectBrandedType,
+  detectUniformBrandedType,
+} from "../../shared/branded-type-detector.js";
 import { isInternalTypeSymbol } from "../../shared/constants.js";
 import { extractInlineObjectProperties as extractInlineObjectPropertiesShared } from "../../shared/inline-object-extractor.js";
 import { isInlineObjectType } from "../../shared/inline-object-utils.js";
@@ -175,6 +179,20 @@ function resolveFieldTypeInternal(
       });
     }
 
+    // Check if all non-null types are branded primitives with the same base type
+    // This handles cases like: boolean & { __nominal: true }
+    // which expands to: (true & { __nominal: true }) | (false & { __nominal: true })
+    const uniformBrandedResult = detectUniformBrandedType(nonNullTypes);
+    if (
+      uniformBrandedResult.isBranded &&
+      uniformBrandedResult.baseType !== null
+    ) {
+      return createPrimitiveType({
+        name: uniformBrandedResult.baseType,
+        nullable,
+      });
+    }
+
     if (nonNullTypes.length === 1) {
       const nonNullTypeNode =
         typeNode && ts.isUnionTypeNode(typeNode)
@@ -235,18 +253,45 @@ function resolveFieldTypeInternal(
     return createLiteralType(typeString);
   }
 
-  // Intersection types in field context are ALWAYS treated as inline objects
-  // GraphQL doesn't have intersection types, so we must expand them
+  // Intersection types in field context
+  // GraphQL doesn't have intersection types, so we must resolve them appropriately
   if (type.isIntersection()) {
-    // If the intersection has an alias that's in knownTypeNames, use it
+    // 1. If the intersection has an alias that's in knownTypeNames, use it as reference
     if (type.aliasSymbol) {
       const aliasName = type.aliasSymbol.getName();
       if (isKnownSchemaType(aliasName, type.aliasSymbol, ctx)) {
         return createReferenceType({ name: aliasName, nullable: false });
       }
+
+      // 2. Check if aliasSymbol has a globalTypeMapping (custom scalar)
+      const globalMapping = globalTypeMappings.find(
+        (m) => m.typeName === aliasName,
+      );
+      if (globalMapping) {
+        return createScalarType({
+          name: globalMapping.scalarName,
+          scalarInfo: {
+            scalarName: globalMapping.scalarName,
+            typeName: globalMapping.typeName,
+            baseType: undefined,
+            isCustom: true,
+            only: globalMapping.only,
+          },
+          nullable: false,
+        });
+      }
+    }
+
+    // 3. Check if this is a branded primitive type pattern
+    const brandedResult = detectBrandedType(type);
+    if (brandedResult.isBranded && brandedResult.baseType !== null) {
+      return createPrimitiveType({
+        name: brandedResult.baseType,
+        nullable: false,
+      });
     }
 
-    // Otherwise, treat as inline object
+    // 4. Otherwise, treat as inline object
     return tryExtractAsInlineObject(type, ctx);
   }
 
@@ -287,6 +332,28 @@ function resolveFieldTypeInternal(
     }
   }
 
+  // Type alias expansion: type aliases not in knownTypeNames should be expanded as inline objects
+  // This handles cases like: type MyPayload = { user: User; success: boolean; }
+  // where MyPayload is used as return type but not declared as a schema type
+  // Only expand if the underlying type is an anonymous object literal, not a named type
+  // IMPORTANT: Only expand if the name doesn't exist in schema at all.
+  // If the name exists but symbols don't match, that's a shadowing case handled by later logic.
+  if (type.aliasSymbol) {
+    const aliasName = type.aliasSymbol.getName();
+    if (!knownTypeNames.has(aliasName)) {
+      // Check if this is an anonymous object type (not an interface or another named type)
+      // using ts.ObjectFlags.Anonymous for a more robust check than internal symbol names
+      const isAnonymousObject =
+        (type.flags & ts.TypeFlags.Object) !== 0 &&
+        ((type as ts.ObjectType).objectFlags & ts.ObjectFlags.Anonymous) !== 0;
+
+      if (isAnonymousObject) {
+        // Not a known schema type and is an anonymous object - expand to generate Payload type
+        return tryExtractAsInlineObject(type, ctx);
+      }
+    }
+  }
+
   // Extract type name from typeNode first (takes precedence over type.symbol).
   // This handles cases like:
   // - `typeof def` where the type's symbol is internal (__type, __object)
@@ -406,7 +473,7 @@ function tryExtractAsInlineObject(
   type: ts.Type,
   ctx: InternalFieldTypeContext,
 ): TSTypeReference {
-  const { visitedTypes } = ctx;
+  const { visitedTypes, checker } = ctx;
   if (visitedTypes.has(type)) {
     // Cycle detected, return a placeholder reference
     const typeName = type.symbol?.getName() ?? "Unknown";
@@ -417,11 +484,34 @@ function tryExtractAsInlineObject(
 
   const inlineProperties = extractInlineObjectPropertiesShared(
     type,
-    ctx.checker,
+    checker,
     (propType) => resolveFieldTypeInternal(propType, undefined, ctx),
   );
 
-  return createInlineObjectType(inlineProperties);
+  // Extract type-level TSDoc from the alias symbol if present (Requirement 7.2)
+  // Only extract from user-defined types, not built-in TypeScript utility types
+  let description: string | null = null;
+  let deprecated: DeprecationInfo | null = null;
+  if (type.aliasSymbol) {
+    const declarations = type.aliasSymbol.getDeclarations();
+    const isUserDefined =
+      declarations?.some((decl) => {
+        const sourceFile = decl.getSourceFile();
+        return !sourceFile.isDeclarationFile;
+      }) ?? false;
+
+    if (isUserDefined) {
+      const tsdocInfo = extractTsDocFromSymbol(type.aliasSymbol, checker);
+      description = tsdocInfo.description;
+      deprecated = tsdocInfo.deprecated;
+    }
+  }
+
+  return createInlineObjectType({
+    properties: inlineProperties,
+    description,
+    deprecated,
+  });
 }
 
 /**

package/src/type-extractor/extractor/type-extractor.ts

@@ -9,6 +9,8 @@ import {
   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 {
@@ -157,7 +159,11 @@ function tryExtractAsInlineObject(
     (t) => convertTsTypeToReference(t, ctx).tsType,
   );
   return {
-    tsType: createInlineObjectType(inlineProperties),
+    tsType: createInlineObjectType({
+      properties: inlineProperties,
+      description: null,
+      deprecated: null,
+    }),
   };
 }
 
@@ -404,6 +410,21 @@ interface FieldExtractionResult {
   diagnostics: Diagnostic[];
 }
 
+function collectAllFieldNames(
+  type: ts.Type,
+  checker: ts.TypeChecker,
+): ReadonlySet<string> {
+  const properties = extractPropertySymbols(type, checker);
+  const fieldNames = new Set<string>();
+  for (const prop of properties) {
+    const propName = prop.getName();
+    if (!propName.startsWith(" $")) {
+      fieldNames.add(propName);
+    }
+  }
+  return fieldNames;
+}
+
 interface ExtractFieldsParams {
   readonly type: ts.Type;
   readonly checker: ts.TypeChecker;
@@ -414,6 +435,7 @@ interface ExtractFieldsParams {
   readonly sourceFiles: ReadonlySet<string>;
   readonly scalarMappingTable: ScalarBaseTypeMappingTable | null;
   readonly scalarMappingContext: ScalarMappingContext;
+  readonly ignoreFields: ReadonlySet<string> | null;
 }
 
 function extractFieldsFromType(
@@ -429,6 +451,7 @@ function extractFieldsFromType(
     sourceFiles,
     scalarMappingTable,
     scalarMappingContext,
+    ignoreFields,
   } = params;
   const fields: FieldDefinition[] = [];
   const diagnostics: Diagnostic[] = [];
@@ -441,6 +464,10 @@ function extractFieldsFromType(
       continue;
     }
 
+    if (ignoreFields?.has(propName)) {
+      continue;
+    }
+
     const propType = checker.getTypeOfSymbol(prop);
     const declarations = prop.getDeclarations();
     const declaration = declarations?.[0];
@@ -945,6 +972,19 @@ function processReexportedSymbol(
       ? 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: [] }
@@ -958,6 +998,7 @@ function processReexportedSymbol(
           sourceFiles: scannedSourceFiles,
           scalarMappingTable,
           scalarMappingContext,
+          ignoreFields,
         });
   diagnostics.push(...fieldResult.diagnostics);
 
@@ -1130,17 +1171,23 @@ interface ExtractInlineObjectMembersParams {
   readonly checker: ts.TypeChecker;
   readonly globalTypeMappings: ReadonlyArray<GlobalTypeMapping>;
   readonly knownTypeNames: ReadonlySet<string>;
+  readonly typeNode: ts.TypeNode | undefined;
 }
 
 function extractInlineObjectMembers(
   params: ExtractInlineObjectMembersParams,
 ): InlineObjectExtractionResult | null {
-  const { type, checker, globalTypeMappings, knownTypeNames } = 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) =>
@@ -1163,28 +1210,45 @@ function extractInlineObjectMembers(
     visitedTypes: new WeakSet(),
   };
 
-  for (const memberType of nonNullTypes) {
-    if (isAnonymousObjectType(memberType)) {
-      hasInlineObjects = true;
-      const properties = memberType.getProperties();
-      const memberProperties: InlineObjectProperty[] = [];
+  if (memberTypeNodes.length > 0) {
+    for (const memberNode of memberTypeNodes) {
+      if (ts.isTypeReferenceNode(memberNode)) {
+        hasNamedTypes = true;
+      } else {
+        hasInlineObjects = 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: InlineObjectProperty[] = [];
 
-      for (const prop of properties) {
-        const propType = checker.getTypeOfSymbol(prop);
-        const tsdocInfo = extractTsDocFromSymbol(prop, checker);
-        const typeResult = convertTsTypeToReference(propType, ctx);
+        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,
-        });
-      }
+          memberProperties.push({
+            propertyName: prop.getName(),
+            propertyType: typeResult.tsType,
+            description: tsdocInfo.description ?? null,
+            deprecated: tsdocInfo.deprecated ?? null,
+          });
+        }
 
-      members.push({ properties: memberProperties });
-    } else {
-      hasNamedTypes = true;
+        members.push({ properties: memberProperties });
+      }
     }
   }
 
@@ -1415,6 +1479,7 @@ export function extractTypesFromProgram(
           checker,
           globalTypeMappings,
           knownTypeNames,
+          typeNode: typeAliasTypeNode,
         });
         const tsdocInfo = extractTsDocInfo(node, checker);
 
@@ -1468,6 +1533,19 @@ export function extractTypesFromProgram(
           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: [] }
@@ -1483,6 +1561,7 @@ export function extractTypesFromProgram(
                 scalarMappingContext: name.endsWith("Input")
                   ? "input"
                   : "output",
+                ignoreFields,
               });
         const fields = fieldResult.fields;
         diagnostics.push(...fieldResult.diagnostics);
@@ -1517,11 +1596,9 @@ export function extractTypesFromProgram(
           }
         }
 
-        const inlineObjectMembers =
-          inlineObjectResult?.hasInlineObjects &&
-          !inlineObjectResult.hasNamedTypes
-            ? inlineObjectResult.members
-            : null;
+        const inlineObjectMembers = inlineObjectResult?.hasInlineObjects
+          ? inlineObjectResult.members
+          : null;
 
         const typeInfo: ExtractedTypeInfo = {
           metadata,