@gqlkit-ts/cli 0.4.1 → 0.5.1

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

@@ -1,8 +1,28 @@
 import ts from "typescript";
+import {
+  getSourceLocationFromNode,
+  type SourceLocation,
+} from "../../shared/source-location.js";
 import {
   isExported,
   resolveOriginalSymbol,
 } from "../../shared/typescript-utils.js";
+import type { Diagnostic } from "../types/index.js";
+
+/**
+ * Tracks location and symbol of a type declaration for duplicate detection.
+ */
+interface TypeDeclarationLocation {
+  readonly location: SourceLocation;
+  readonly symbol: ts.Symbol | null;
+}
+
+/**
+ * Formats a source location as a human-readable string.
+ */
+function formatLocation(location: SourceLocation): string {
+  return `${location.file}:${location.line}`;
+}
 
 export interface TypeNameCollectionResult {
   readonly typeNames: ReadonlySet<string>;
@@ -13,6 +33,11 @@ export interface TypeNameCollectionResult {
    * This allows recognizing `ExternalUser` as `User` in field types.
    */
   readonly underlyingSymbolToTypeName: ReadonlyMap<ts.Symbol, string>;
+  /**
+   * Diagnostics collected during type name collection.
+   * Contains errors for duplicate type exports.
+   */
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
 }
 
 /**
@@ -33,8 +58,51 @@ export function collectDeclaredTypeNames(
   const typeNames = new Set<string>();
   const typeSymbols = new Map<string, ts.Symbol>();
   const underlyingSymbolToTypeName = new Map<ts.Symbol, string>();
+  const diagnostics: Diagnostic[] = [];
   const checker = program.getTypeChecker();
 
+  const typeLocations = new Map<string, TypeDeclarationLocation>();
+
+  /**
+   * Registers a type name and checks for duplicates.
+   * Returns true if this is a new type, false if it's a duplicate.
+   */
+  function registerTypeName(
+    name: string,
+    location: SourceLocation,
+    symbol: ts.Symbol | undefined,
+  ): boolean {
+    const resolvedSymbol = symbol
+      ? resolveOriginalSymbol(symbol, checker)
+      : null;
+    const existing = typeLocations.get(name);
+    if (existing) {
+      // Check if both symbols resolve to the same underlying type
+      // (e.g., re-exports of the same type from different files)
+      if (
+        resolvedSymbol &&
+        existing.symbol &&
+        resolvedSymbol === existing.symbol
+      ) {
+        // Same underlying type - not a true duplicate, skip silently
+        return false;
+      }
+      diagnostics.push({
+        code: "DUPLICATE_TYPE_EXPORT",
+        message: `Type '${name}' is exported from multiple files. First defined at ${formatLocation(existing.location)}.`,
+        severity: "error",
+        location,
+      });
+      return false;
+    }
+    typeLocations.set(name, { location, symbol: resolvedSymbol });
+    typeNames.add(name);
+    if (resolvedSymbol) {
+      typeSymbols.set(name, resolvedSymbol);
+    }
+    return true;
+  }
+
   for (const filePath of sourceFiles) {
     const sourceFile = program.getSourceFile(filePath);
     if (!sourceFile) continue;
@@ -43,11 +111,11 @@ export function collectDeclaredTypeNames(
       // Direct type declarations
       if (ts.isTypeAliasDeclaration(node) && isExported(node)) {
         const name = node.name.getText(sourceFile);
-        typeNames.add(name);
+        const location = getSourceLocationFromNode(node)!;
         const symbol = checker.getSymbolAtLocation(node.name);
-        if (symbol) {
-          typeSymbols.set(name, resolveOriginalSymbol(symbol, checker));
+        const isNew = registerTypeName(name, location, symbol);
 
+        if (isNew && symbol) {
           // For type aliases like `type User = ExternalUser;`,
           // also track the underlying type's symbol
           const type = checker.getTypeAtLocation(node.type);
@@ -62,19 +130,15 @@ export function collectDeclaredTypeNames(
       }
       if (ts.isInterfaceDeclaration(node) && isExported(node)) {
         const name = node.name.getText(sourceFile);
-        typeNames.add(name);
+        const location = getSourceLocationFromNode(node)!;
         const symbol = checker.getSymbolAtLocation(node.name);
-        if (symbol) {
-          typeSymbols.set(name, resolveOriginalSymbol(symbol, checker));
-        }
+        registerTypeName(name, location, symbol);
       }
       if (ts.isEnumDeclaration(node) && isExported(node)) {
         const name = node.name.getText(sourceFile);
-        typeNames.add(name);
+        const location = getSourceLocationFromNode(node)!;
         const symbol = checker.getSymbolAtLocation(node.name);
-        if (symbol) {
-          typeSymbols.set(name, resolveOriginalSymbol(symbol, checker));
-        }
+        registerTypeName(name, location, symbol);
       }
 
       // Re-exports: `export type { ... } from "..."` or `export type * from "..."`
@@ -85,11 +149,9 @@ export function collectDeclaredTypeNames(
             for (const element of node.exportClause.elements) {
               // Use the exported name (element.name), not the property name
               const name = element.name.getText(sourceFile);
-              typeNames.add(name);
+              const location = getSourceLocationFromNode(element)!;
               const symbol = checker.getSymbolAtLocation(element.name);
-              if (symbol) {
-                typeSymbols.set(name, resolveOriginalSymbol(symbol, checker));
-              }
+              registerTypeName(name, location, symbol);
             }
           }
         } else if (node.moduleSpecifier) {
@@ -103,8 +165,8 @@ export function collectDeclaredTypeNames(
               const name = exp.getName();
               // Check if the export is a type (not a value)
               if (isTypeExport(exp)) {
-                typeNames.add(name);
-                typeSymbols.set(name, resolveOriginalSymbol(exp, checker));
+                const location = getSourceLocationFromNode(node)!;
+                registerTypeName(name, location, exp);
               }
             }
           }
@@ -113,7 +175,7 @@ export function collectDeclaredTypeNames(
     });
   }
 
-  return { typeNames, typeSymbols, underlyingSymbolToTypeName };
+  return { typeNames, typeSymbols, underlyingSymbolToTypeName, diagnostics };
 }
 
 /**

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

@@ -28,6 +28,7 @@ export type DiagnosticCode =
   | "CONFLICTING_SCALAR_TYPE"
   | "INVALID_DEFINE_CALL"
   | "CONFIG_SYNTAX_ERROR"
+  | "CONFIG_FILE_NOT_FOUND"
   | "CONFIG_MISSING_PROPERTY"
   | "CONFIG_INVALID_TYPE"
   | "CONFIG_INVALID_PATH"
@@ -95,7 +96,8 @@ export type DiagnosticCode =
   | "TYPENAME_FIELD_STRUCTURE_MISMATCH"
   | "DUPLICATE_TYPENAME_VALUE"
   | "IGNORE_FIELD_NOT_FOUND"
-  | "IGNORE_ALL_FIELDS";
+  | "IGNORE_ALL_FIELDS"
+  | "DUPLICATE_TYPE_EXPORT";
 
 export interface Diagnostic {
   readonly code: DiagnosticCode;