@gqlkit-ts/cli 0.6.0 → 0.7.1

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

@@ -1,6 +1,9 @@
 import { resolve } from "node:path";
 import ts from "typescript";
-import { isInternalTypeSymbol } from "../../shared/constants.js";
+import {
+  isBuiltInScalar,
+  isInternalTypeSymbol,
+} from "../../shared/constants.js";
 import { detectDefaultValueMetadata } from "../../shared/default-value-detector.js";
 import {
   type DirectiveArgumentValue,
@@ -50,10 +53,11 @@ import type {
 import {
   createArrayType,
   createInlineObjectType,
-  createLiteralType,
+  createNumericLiteralType,
   createPrimitiveType,
   createReferenceType,
   createScalarType,
+  createStringLiteralType,
   createUnionType,
   type Diagnostic,
   type EnumMemberInfo,
@@ -65,7 +69,11 @@ import {
   type TypeKind,
   type TypeMetadata,
 } from "../types/index.js";
-import { resolveFieldType } from "./field-type-resolver.js";
+import {
+  type DiscoveredTypeEntry,
+  type FieldTypeResolverDiagnostic,
+  resolveFieldType,
+} from "./field-type-resolver.js";
 
 /**
  * Global type mapping configuration.
@@ -98,6 +106,7 @@ export interface ExtractionResult {
   readonly diagnostics: ReadonlyArray<Diagnostic>;
   readonly detectedScalarNames: ReadonlyArray<string>;
   readonly detectedScalars: ReadonlyArray<ScalarMetadataInfo>;
+  readonly discoveredTypeNames: ReadonlySet<string>;
 }
 
 function isDefaultExport(node: ts.Node, sourceFile: ts.SourceFile): boolean {
@@ -163,6 +172,7 @@ function tryExtractAsInlineObject(
       properties: inlineProperties,
       description: null,
       deprecated: null,
+      hintName: null,
     }),
   };
 }
@@ -260,6 +270,7 @@ function convertTsTypeToReference(
       tsType: createUnionType({
         members: memberResults.map((r) => r.tsType),
         nullable,
+        aliasName: type.aliasSymbol?.getName() ?? null,
       }),
     };
   }
@@ -307,12 +318,12 @@ function convertTsTypeToReference(
   }
   if (type.flags & ts.TypeFlags.StringLiteral) {
     return {
-      tsType: createLiteralType(typeString.replace(/"/g, "")),
+      tsType: createStringLiteralType(typeString.replace(/"/g, "")),
     };
   }
   if (type.flags & ts.TypeFlags.NumberLiteral) {
     return {
-      tsType: createLiteralType(typeString),
+      tsType: createNumericLiteralType(typeString),
     };
   }
 
@@ -436,6 +447,7 @@ interface ExtractFieldsParams {
   readonly scalarMappingTable: ScalarBaseTypeMappingTable | null;
   readonly scalarMappingContext: ScalarMappingContext;
   readonly ignoreFields: ReadonlySet<string> | null;
+  readonly discoveredTypes: Map<string, DiscoveredTypeEntry> | null;
 }
 
 function extractFieldsFromType(
@@ -452,6 +464,7 @@ function extractFieldsFromType(
     scalarMappingTable,
     scalarMappingContext,
     ignoreFields,
+    discoveredTypes,
   } = params;
   const fields: FieldDefinition[] = [];
   const diagnostics: Diagnostic[] = [];
@@ -528,6 +541,7 @@ function extractFieldsFromType(
       propTypeNode = declaration.type;
     }
 
+    const fieldDiagnostics: FieldTypeResolverDiagnostic[] = [];
     const resolvedType = resolveFieldType(actualPropType, propTypeNode, {
       checker,
       knownTypeNames,
@@ -537,7 +551,22 @@ function extractFieldsFromType(
       sourceFiles,
       scalarMappingTable,
       scalarMappingContext,
+      discoveredTypes,
+      diagnostics: fieldDiagnostics,
     });
+    for (const d of fieldDiagnostics) {
+      diagnostics.push({
+        code: d.code,
+        message: `Field '${propName}': ${d.message}`,
+        severity: d.severity,
+        location: getSourceLocationFromNode(declaration),
+      });
+    }
+
+    // Skip fields with never type — they have no GraphQL representation
+    if (resolvedType.kind === "never") {
+      continue;
+    }
 
     // Preserve nullability from original WithDirectives type
     const tsType =
@@ -847,6 +876,7 @@ interface ProcessReexportedSymbolParams {
   readonly scannedSourceFiles: ReadonlySet<string>;
   readonly scalarMappingTable: ScalarBaseTypeMappingTable | null;
   readonly scalarMappingContext: ScalarMappingContext;
+  readonly discoveredTypes: Map<string, DiscoveredTypeEntry> | null;
 }
 
 interface ProcessReexportedSymbolResult {
@@ -874,6 +904,7 @@ function processReexportedSymbol(
     scannedSourceFiles,
     scalarMappingTable,
     scalarMappingContext,
+    discoveredTypes,
   } = params;
 
   const diagnostics: Diagnostic[] = [];
@@ -999,6 +1030,7 @@ function processReexportedSymbol(
           scalarMappingTable,
           scalarMappingContext,
           ignoreFields,
+          discoveredTypes,
         });
   diagnostics.push(...fieldResult.diagnostics);
 
@@ -1036,16 +1068,13 @@ function processExportDeclaration(
   underlyingSymbolToTypeName: ReadonlyMap<ts.Symbol, string>,
   scannedSourceFiles: ReadonlySet<string>,
   scalarMappingTable: ScalarBaseTypeMappingTable | null,
+  discoveredTypes: Map<string, DiscoveredTypeEntry> | null,
 ): ProcessExportDeclarationResult {
   const types: ExtractedTypeInfo[] = [];
   const diagnostics: Diagnostic[] = [];
   const detectedScalarNames: string[] = [];
   const detectedScalars: ScalarMetadataInfo[] = [];
 
-  if (!node.isTypeOnly) {
-    return { types, diagnostics, detectedScalarNames, detectedScalars };
-  }
-
   const exportClause = node.exportClause;
 
   const symbolsToProcess: Array<{
@@ -1054,8 +1083,35 @@ function processExportDeclaration(
     type: ts.Type;
   }> = [];
 
-  if (exportClause && ts.isNamedExports(exportClause)) {
+  if (node.isTypeOnly && exportClause && ts.isNamedExports(exportClause)) {
+    // Declaration-level type-only: `export type { Foo, Bar } from "..."`
+    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 (
+    !node.isTypeOnly &&
+    exportClause &&
+    ts.isNamedExports(exportClause)
+  ) {
+    // Specifier-level type-only: `export { type Foo, type Bar } from "..."`
     for (const specifier of exportClause.elements) {
+      if (!specifier.isTypeOnly) continue;
       const exportedName = specifier.name.text;
       const localTargetSymbol =
         checker.getExportSpecifierLocalTargetSymbol(specifier);
@@ -1074,7 +1130,7 @@ function processExportDeclaration(
         type,
       });
     }
-  } else if (!exportClause && node.moduleSpecifier) {
+  } else if (node.isTypeOnly && !exportClause && node.moduleSpecifier) {
     const moduleSymbol = checker.getSymbolAtLocation(node.moduleSpecifier);
     if (!moduleSymbol) {
       const location = getSourceLocationFromNode(node)!;
@@ -1132,6 +1188,7 @@ function processExportDeclaration(
       scannedSourceFiles,
       scalarMappingTable,
       scalarMappingContext: exportedName.endsWith("Input") ? "input" : "output",
+      discoveredTypes,
     });
 
     if (result.skip) continue;
@@ -1317,6 +1374,7 @@ export function extractTypesFromProgram(
   const diagnostics: Diagnostic[] = [];
   const detectedScalarNames = new Set<string>();
   const detectedScalars: ScalarMetadataInfo[] = [];
+  const discoveredTypes = new Map<string, DiscoveredTypeEntry>();
   const {
     globalTypeMappings,
     knownTypeNames,
@@ -1562,6 +1620,7 @@ export function extractTypesFromProgram(
                   ? "input"
                   : "output",
                 ignoreFields,
+                discoveredTypes,
               });
         const fields = fieldResult.fields;
         diagnostics.push(...fieldResult.diagnostics);
@@ -1624,6 +1683,7 @@ export function extractTypesFromProgram(
           underlyingSymbolToTypeName,
           scannedSourceFilesSet,
           scalarMappingTable,
+          discoveredTypes,
         );
         types.push(...result.types);
         diagnostics.push(...result.diagnostics);
@@ -1635,10 +1695,87 @@ export function extractTypesFromProgram(
     });
   }
 
+  // Process transitively discovered types
+  const processedDiscovered = new Set<string>();
+  while (discoveredTypes.size > processedDiscovered.size) {
+    for (const [name, entry] of discoveredTypes) {
+      if (processedDiscovered.has(name)) continue;
+      processedDiscovered.add(name);
+      if (knownTypeNames.has(name)) continue;
+
+      const { fields } = extractFieldsFromType({
+        type: entry.tsType,
+        checker,
+        globalTypeMappings,
+        knownTypeNames,
+        knownTypeSymbols,
+        underlyingSymbolToTypeName,
+        sourceFiles: scannedSourceFilesSet,
+        scalarMappingTable,
+        scalarMappingContext: "output",
+        ignoreFields: null,
+        discoveredTypes,
+      });
+      if (fields.length === 0) continue;
+
+      types.push({
+        metadata: {
+          name,
+          kind: "object",
+          sourceFile: entry.sourceFile,
+          sourceLocation: entry.sourceLocation,
+          exportKind: "named",
+          description: null,
+          deprecated: null,
+          directives: null,
+        },
+        fields,
+        enumMembers: null,
+        unionMembers: null,
+        implementedInterfaces: null,
+        inlineObjectMembers: null,
+      });
+    }
+  }
+
+  // Collect scalar names from field types (e.g., unknown → Unknown scalar)
+  for (const typeInfo of types) {
+    for (const field of typeInfo.fields) {
+      collectScalarNamesFromType(field.tsType, detectedScalarNames);
+    }
+  }
+
   return {
     types,
     diagnostics,
     detectedScalarNames: [...detectedScalarNames],
     detectedScalars,
+    discoveredTypeNames: new Set(discoveredTypes.keys()),
   };
 }
+
+function collectScalarNamesFromType(
+  tsType: TSTypeReference,
+  scalarNames: Set<string>,
+): void {
+  if (
+    tsType.kind === "scalar" &&
+    tsType.scalarInfo?.isCustom &&
+    !isBuiltInScalar(tsType.scalarInfo.scalarName)
+  ) {
+    scalarNames.add(tsType.scalarInfo.scalarName);
+  }
+  if (tsType.elementType) {
+    collectScalarNamesFromType(tsType.elementType, scalarNames);
+  }
+  if (tsType.members) {
+    for (const member of tsType.members) {
+      collectScalarNamesFromType(member, scalarNames);
+    }
+  }
+  if (tsType.inlineObjectProperties) {
+    for (const prop of tsType.inlineObjectProperties) {
+      collectScalarNamesFromType(prop.tsType, scalarNames);
+    }
+  }
+}

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

@@ -142,9 +142,9 @@ export function collectDeclaredTypeNames(
       }
 
       // Re-exports: `export type { ... } from "..."` or `export type * from "..."`
-      if (ts.isExportDeclaration(node) && node.isTypeOnly) {
-        if (node.exportClause) {
-          // Named re-exports: `export type { Foo, Bar } from "..."`
+      if (ts.isExportDeclaration(node)) {
+        if (node.isTypeOnly && node.exportClause) {
+          // Declaration-level type-only named re-exports: `export type { Foo, Bar } from "..."`
           if (ts.isNamedExports(node.exportClause)) {
             for (const element of node.exportClause.elements) {
               // Use the exported name (element.name), not the property name
@@ -154,7 +154,22 @@ export function collectDeclaredTypeNames(
               registerTypeName(name, location, symbol);
             }
           }
-        } else if (node.moduleSpecifier) {
+        } else if (!node.isTypeOnly && node.exportClause) {
+          // Specifier-level type-only re-exports: `export { type Foo, type Bar } from "..."`
+          if (ts.isNamedExports(node.exportClause)) {
+            for (const element of node.exportClause.elements) {
+              if (!element.isTypeOnly) continue;
+              const name = element.name.getText(sourceFile);
+              const location = getSourceLocationFromNode(element)!;
+              const symbol = checker.getSymbolAtLocation(element.name);
+              registerTypeName(name, location, symbol);
+            }
+          }
+        } else if (
+          node.isTypeOnly &&
+          !node.exportClause &&
+          node.moduleSpecifier
+        ) {
           // Wildcard re-exports: `export type * from "..."`
           const moduleSymbol = checker.getSymbolAtLocation(
             node.moduleSpecifier,

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

@@ -95,9 +95,18 @@ export type DiagnosticCode =
   | "NULLABLE_TYPENAME_PROPERTY"
   | "TYPENAME_FIELD_STRUCTURE_MISMATCH"
   | "DUPLICATE_TYPENAME_VALUE"
+  | "UNNAMEABLE_UNION_MEMBER"
   | "IGNORE_FIELD_NOT_FOUND"
   | "IGNORE_ALL_FIELDS"
-  | "DUPLICATE_TYPE_EXPORT";
+  | "DUPLICATE_TYPE_EXPORT"
+  | "CONFIG_INVALID_DISCRIMINATOR_FIELDS"
+  | "CONFIG_INVALID_DISCRIMINATOR_ENTRY"
+  | "CONFIG_EMPTY_DISCRIMINATOR_FIELDS"
+  | "DISCRIMINATOR_FIELD_NOT_FOUND"
+  | "DISCRIMINATOR_FIELD_NOT_STRING_LITERAL"
+  | "DISCRIMINATOR_DUPLICATE_VALUE_TUPLE"
+  | "DISCRIMINATOR_UNKNOWN_UNION"
+  | "CYCLE_DETECTED";
 
 export interface Diagnostic {
   readonly code: DiagnosticCode;

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

@@ -15,10 +15,11 @@ export type {
 export {
   createArrayType,
   createInlineObjectType,
-  createLiteralType,
+  createNumericLiteralType,
   createPrimitiveType,
   createReferenceType,
   createScalarType,
+  createStringLiteralType,
   createUnionType,
 } from "./ts-type-reference-factory.js";
 export type {

package/src/type-extractor/types/ts-type-reference-factory.ts

@@ -25,6 +25,7 @@ function createTSTypeReference(
     inlineObjectProperties: null,
     inlineObjectDescription: null,
     inlineObjectDeprecated: null,
+    inlineObjectHintName: null,
     inlineEnumMembers: null,
     externalEnumSymbol: null,
     externalEnumDescription: null,
@@ -68,6 +69,8 @@ export function createArrayType(elementType: TSTypeReference): TSTypeReference {
 interface CreateUnionTypeParams {
   readonly members: ReadonlyArray<TSTypeReference>;
   readonly nullable: boolean;
+  /** The TypeScript type alias name for this union (e.g., "ItemPart" for `type ItemPart = A | B`) */
+  readonly aliasName: string | null;
 }
 
 export function createUnionType(
@@ -75,7 +78,11 @@ export function createUnionType(
 ): TSTypeReference {
   return createTSTypeReference({
     kind: "union",
-    overrides: { members: params.members, nullable: params.nullable },
+    overrides: {
+      members: params.members,
+      nullable: params.nullable,
+      name: params.aliasName,
+    },
   });
 }
 
@@ -85,6 +92,8 @@ interface CreateInlineObjectTypeParams {
   readonly description: string | null;
   /** @deprecated tag from the type alias (null for true inline objects) */
   readonly deprecated: DeprecationInfo | null;
+  /** Original type name hint for inline objects extracted from external types */
+  readonly hintName: string | null;
 }
 
 export function createInlineObjectType(
@@ -96,6 +105,7 @@ export function createInlineObjectType(
       inlineObjectProperties: params.properties,
       inlineObjectDescription: params.description,
       inlineObjectDeprecated: params.deprecated,
+      inlineObjectHintName: params.hintName,
     },
   });
 }
@@ -119,8 +129,19 @@ export function createScalarType(
   });
 }
 
-export function createLiteralType(name: string): TSTypeReference {
-  return createTSTypeReference({ kind: "literal", overrides: { name } });
+export function createNeverType(): TSTypeReference {
+  return createTSTypeReference({ kind: "never", overrides: {} });
+}
+
+export function createStringLiteralType(name: string): TSTypeReference {
+  return createTSTypeReference({ kind: "stringLiteral", overrides: { name } });
+}
+
+export function createNumericLiteralType(name: string): TSTypeReference {
+  return createTSTypeReference({
+    kind: "numericLiteral",
+    overrides: { name },
+  });
 }
 
 interface CreateInlineEnumTypeParams {

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

@@ -45,10 +45,12 @@ export type TSTypeReferenceKind =
   | "reference"
   | "array"
   | "union"
-  | "literal"
+  | "stringLiteral"
+  | "numericLiteral"
   | "scalar"
   | "inlineObject"
-  | "inlineEnum";
+  | "inlineEnum"
+  | "never";
 
 /**
  * Information about an inline enum member (string literal union value).
@@ -76,6 +78,8 @@ export interface TSTypeReference {
   readonly inlineObjectDeprecated: DeprecationInfo | null;
   /** Inline enum members when kind is "inlineEnum" */
   readonly inlineEnumMembers: ReadonlyArray<InlineEnumMemberInfo> | null;
+  /** Original type name hint for inline objects extracted from external types */
+  readonly inlineObjectHintName: string | null;
   /** External TypeScript enum symbol for deduplication (Requirement 5.2) */
   readonly externalEnumSymbol: ts.Symbol | null;
   /** TSDoc description from the external enum type itself (Requirement 6.1) */

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

@@ -10,7 +10,12 @@ export interface ValidateTypesOptions {
   readonly types: ReadonlyArray<GraphQLTypeInfo>;
   readonly customScalarNames: ReadonlyArray<string> | null;
 }
-const PLACEHOLDER_TYPES = new Set(["__INLINE_OBJECT__", "__INLINE_ENUM__"]);
+const PLACEHOLDER_TYPES = new Set([
+  "__INLINE_OBJECT__",
+  "__INLINE_ENUM__",
+  "__INLINE_UNION__",
+  "__NEVER__",
+]);
 
 export function validateTypes(options: ValidateTypesOptions): ValidationResult {
   const { types, customScalarNames } = options;