@gqlkit-ts/cli 0.2.0 → 0.3.0

package/src/shared/enum-prefix-detector.ts

@@ -0,0 +1,99 @@
+/**
+ * Converts an enum name from any naming convention to UPPER_SNAKE_CASE.
+ *
+ * Supports PascalCase, camelCase, UPPER_SNAKE_CASE, and single word inputs.
+ *
+ * @example
+ * toUpperSnakeCase("UserStatus") // => "USER_STATUS"
+ * toUpperSnakeCase("userStatus") // => "USER_STATUS"
+ * toUpperSnakeCase("USER_STATUS") // => "USER_STATUS"
+ * toUpperSnakeCase("Status") // => "STATUS"
+ */
+export function toUpperSnakeCase(name: string): string {
+  return name
+    .replace(/([a-z])([A-Z])/g, "$1_$2")
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
+    .toUpperCase();
+}
+
+/**
+ * Builds the prefix candidate string for enum prefix stripping.
+ *
+ * Converts the enum name to UPPER_SNAKE_CASE and appends "_" to create
+ * the prefix that will be checked against all enum values.
+ *
+ * @example
+ * buildEnumPrefixCandidate("UserStatus") // => "USER_STATUS_"
+ * buildEnumPrefixCandidate("userStatus") // => "USER_STATUS_"
+ * buildEnumPrefixCandidate("USER_STATUS") // => "USER_STATUS_"
+ * buildEnumPrefixCandidate("Status") // => "STATUS_"
+ */
+export function buildEnumPrefixCandidate(enumName: string): string {
+  return `${toUpperSnakeCase(enumName)}_`;
+}
+
+export interface DetectEnumPrefixParams {
+  readonly enumName: string;
+  readonly memberValues: ReadonlyArray<string>;
+}
+
+export interface DetectEnumPrefixResult {
+  readonly shouldStrip: boolean;
+  readonly prefix: string | null;
+}
+
+/**
+ * Detects whether an enum is a candidate for prefix stripping.
+ *
+ * Conditions for stripping:
+ * 1. All memberValues must start with `${toUpperSnakeCase(enumName)}_`
+ * 2. After removing the prefix, the remaining string must be non-empty
+ *
+ * @example
+ * detectEnumPrefix({
+ *   enumName: "UserStatus",
+ *   memberValues: ["USER_STATUS_ACTIVE", "USER_STATUS_INACTIVE"]
+ * })
+ * // => { shouldStrip: true, prefix: "USER_STATUS_" }
+ *
+ * detectEnumPrefix({
+ *   enumName: "UserStatus",
+ *   memberValues: ["ACTIVE", "INACTIVE"]
+ * })
+ * // => { shouldStrip: false, prefix: null }
+ */
+export function detectEnumPrefix(
+  params: DetectEnumPrefixParams,
+): DetectEnumPrefixResult {
+  const { enumName, memberValues } = params;
+
+  if (memberValues.length === 0) {
+    return { shouldStrip: false, prefix: null };
+  }
+
+  const prefixCandidate = buildEnumPrefixCandidate(enumName);
+
+  for (const value of memberValues) {
+    if (!value.startsWith(prefixCandidate)) {
+      return { shouldStrip: false, prefix: null };
+    }
+
+    const stripped = value.slice(prefixCandidate.length);
+    if (stripped === "") {
+      return { shouldStrip: false, prefix: null };
+    }
+  }
+
+  return { shouldStrip: true, prefix: prefixCandidate };
+}
+
+/**
+ * Removes the detected prefix from an enum value.
+ *
+ * @example
+ * stripEnumPrefix("USER_STATUS_ACTIVE", "USER_STATUS_")
+ * // => "ACTIVE"
+ */
+export function stripEnumPrefix(value: string, prefix: string): string {
+  return value.slice(prefix.length);
+}

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

@@ -0,0 +1,109 @@
+/**
+ * IgnoreFields metadata detector.
+ *
+ * This module provides functions to detect ignoreFields metadata embedded
+ * in TypeScript intersection types using the $gqlkitTypeMeta property.
+ */
+
+import ts from "typescript";
+import { METADATA_PROPERTIES } from "./constants.js";
+import { getActualMetadataType } from "./metadata-detector.js";
+
+const TYPE_META_PROPERTY = METADATA_PROPERTIES.TYPE_META;
+
+/**
+ * Parameters for detectIgnoreFieldsMetadata function.
+ */
+export interface DetectIgnoreFieldsParams {
+  readonly type: ts.Type;
+  readonly checker: ts.TypeChecker;
+}
+
+/**
+ * Extracts ignoreFields from a type's metadata.
+ * Returns null if the type doesn't have $gqlkitTypeMeta or ignoreFields is not specified.
+ */
+function extractIgnoreFieldsFromType(
+  type: ts.Type,
+  checker: ts.TypeChecker,
+): ReadonlySet<string> | null {
+  const metaProp = type.getProperty(TYPE_META_PROPERTY);
+  if (!metaProp) {
+    return null;
+  }
+
+  const rawMetadataType = checker.getTypeOfSymbol(metaProp);
+  const metadataType = getActualMetadataType(rawMetadataType);
+  if (!metadataType) {
+    return null;
+  }
+
+  const ignoreFieldsProp = metadataType.getProperty("ignoreFields");
+  if (!ignoreFieldsProp) {
+    return null;
+  }
+
+  const rawIgnoreFieldsType = checker.getTypeOfSymbol(ignoreFieldsProp);
+  const ignoreFieldsType = getActualMetadataType(rawIgnoreFieldsType);
+  if (!ignoreFieldsType) {
+    return null;
+  }
+
+  return extractStringLiteralUnion(ignoreFieldsType);
+}
+
+/**
+ * Extracts string literals from a type (single literal or union of literals).
+ */
+function extractStringLiteralUnion(type: ts.Type): ReadonlySet<string> | null {
+  if (type.flags & ts.TypeFlags.StringLiteral) {
+    const value = (type as ts.StringLiteralType).value;
+    return new Set([value]);
+  }
+
+  if (type.isUnion()) {
+    const values = new Set<string>();
+    for (const member of type.types) {
+      if (member.flags & ts.TypeFlags.StringLiteral) {
+        values.add((member as ts.StringLiteralType).value);
+      }
+    }
+    if (values.size > 0) {
+      return values;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Detects ignoreFields metadata from a TypeScript type.
+ *
+ * This function analyzes TypeScript types to detect ignoreFields metadata
+ * from the $gqlkitTypeMeta property. It extracts string literal or string
+ * literal union types and returns them as a Set.
+ *
+ * @param params - The detection parameters containing type and checker
+ * @returns The ignoreFields set or null if not specified
+ */
+export function detectIgnoreFieldsMetadata(
+  params: DetectIgnoreFieldsParams,
+): ReadonlySet<string> | null {
+  const { type, checker } = params;
+
+  const result = extractIgnoreFieldsFromType(type, checker);
+  if (result) {
+    return result;
+  }
+
+  if (type.isIntersection()) {
+    for (const member of type.types) {
+      const memberResult = extractIgnoreFieldsFromType(member, checker);
+      if (memberResult) {
+        return memberResult;
+      }
+    }
+  }
+
+  return null;
+}

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/type-extractor/converter/graphql-converter.ts

@@ -3,6 +3,10 @@ import {
   isBuiltInScalar,
   PRIMITIVE_TYPE_MAP,
 } from "../../shared/constants.js";
+import {
+  detectEnumPrefix,
+  stripEnumPrefix,
+} from "../../shared/enum-prefix-detector.js";
 import { convertTsTypeToGraphQLType } from "../../shared/type-converter.js";
 import type {
   Diagnostic,
@@ -60,6 +64,11 @@ interface ConvertEnumMembersResult {
   readonly hasError: boolean;
 }
 
+interface ConvertedMemberInfo {
+  readonly convertedName: string;
+  readonly member: EnumMemberInfo;
+}
+
 function convertEnumMembers(
   params: ConvertEnumMembersParams,
 ): ConvertEnumMembersResult {
@@ -69,7 +78,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 +102,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 +135,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,
       });

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

@@ -287,6 +287,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 +428,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 +439,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,