@player-lang/functional-dsl-generator 0.0.2-next.0

package/src/ts-morph-type-finder.ts

@@ -0,0 +1,319 @@
+import { Project, SourceFile, ts } from "ts-morph";
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+
+/**
+ * Information about an unexported type that was found
+ */
+export interface UnexportedTypeLocation {
+  /** The name of the type */
+  typeName: string;
+  /** The file where the type is declared (but not exported) */
+  filePath: string;
+}
+
+/**
+ * Finds type definitions by searching through TypeScript source files using ts-morph.
+ * Handles interfaces, type aliases, classes, and re-exported types.
+ * Supports both local files and types from node_modules.
+ *
+ * Note: This is the ts-morph based implementation. For the TypeScript API based
+ * implementation, see TypeScriptTypeDefinitionFinder in type-resolver.ts.
+ */
+export class TsMorphTypeDefinitionFinder {
+  private project: Project | undefined;
+  private readonly typeLocationCache = new Map<string, string | null>();
+  private readonly unexportedTypes = new Map<string, string>();
+
+  /**
+   * Finds the source file for a type by searching the codebase.
+   * Recursively follows imports to find where a type is actually defined.
+   * Supports both relative imports and node_modules packages.
+   *
+   * @param typeName - The name of the type to find
+   * @param startingFile - The file to start searching from
+   * @returns The path to the file containing the type definition, or null if not found
+   */
+  findTypeSourceFile(typeName: string, startingFile: string): string | null {
+    if (!typeName || !startingFile) return null;
+
+    const cacheKey = `${typeName}:${startingFile}`;
+    if (this.typeLocationCache.has(cacheKey)) {
+      return this.typeLocationCache.get(cacheKey) || null;
+    }
+
+    try {
+      if (!this.project) {
+        this.project = new Project({
+          useInMemoryFileSystem: false,
+          // Enable module resolution for node_modules support
+          skipFileDependencyResolution: false,
+          compilerOptions: {
+            moduleResolution: ts.ModuleResolutionKind.Node16,
+            resolveJsonModule: true,
+          },
+        });
+      }
+
+      const visitedFiles = new Set<string>();
+      const result = this.searchForType(typeName, startingFile, visitedFiles);
+      this.typeLocationCache.set(cacheKey, result);
+      return result;
+    } catch {
+      this.typeLocationCache.set(cacheKey, null);
+      return null;
+    }
+  }
+
+  /**
+   * Recursively searches for a type definition through imports.
+   * Handles both relative imports and node_modules packages.
+   */
+  private searchForType(
+    typeName: string,
+    filePath: string,
+    visitedFiles: Set<string>,
+  ): string | null {
+    if (!existsSync(filePath) || visitedFiles.has(filePath)) return null;
+    visitedFiles.add(filePath);
+
+    try {
+      const sourceFile = this.project!.addSourceFileAtPath(filePath);
+
+      // Check if this file defines and exports the type
+      if (this.fileDefinesType(sourceFile, typeName)) {
+        return filePath;
+      }
+
+      // Check if the file has the type but doesn't export it
+      const typeCheck = this.fileHasTypeDeclaration(sourceFile, typeName);
+      if (typeCheck.found && !typeCheck.exported) {
+        // Track this unexported type for warning
+        this.trackUnexportedType(typeName, typeCheck.filePath);
+      }
+
+      // Search through imports
+      for (const importDecl of sourceFile.getImportDeclarations()) {
+        const moduleSpecifier = importDecl.getModuleSpecifierValue();
+
+        // Check if this import includes the type we're looking for
+        const importedType = this.getImportedTypeFromDeclaration(
+          importDecl,
+          typeName,
+        );
+
+        if (importedType) {
+          // Try to resolve the module to its source file
+          const resolvedSourceFile = importDecl.getModuleSpecifierSourceFile();
+
+          if (resolvedSourceFile) {
+            // Found it via ts-morph module resolution (works for node_modules)
+            const resolvedPath = resolvedSourceFile.getFilePath();
+
+            // For re-exports, we might need to search deeper
+            if (this.fileDefinesType(resolvedSourceFile, typeName)) {
+              return resolvedPath;
+            }
+
+            // Check if it's re-exported from somewhere else
+            const deeperResult = this.searchForType(
+              typeName,
+              resolvedPath,
+              visitedFiles,
+            );
+            if (deeperResult) return deeperResult;
+
+            // If we can't find it deeper, return the resolved path
+            // (the type might be defined in a way we can't detect)
+            return resolvedPath;
+          }
+
+          // Fallback: manual resolution for relative imports
+          if (moduleSpecifier.startsWith(".")) {
+            const resolvedPath = this.resolveImportPath(
+              filePath,
+              moduleSpecifier,
+            );
+            if (resolvedPath) {
+              const result = this.searchForType(
+                typeName,
+                resolvedPath,
+                visitedFiles,
+              );
+              if (result) return result;
+            }
+          }
+        }
+
+        // Also follow relative imports even if they don't explicitly import the type
+        // (the type might be re-exported)
+        if (moduleSpecifier.startsWith(".")) {
+          const resolvedPath = this.resolveImportPath(
+            filePath,
+            moduleSpecifier,
+          );
+          if (resolvedPath) {
+            const result = this.searchForType(
+              typeName,
+              resolvedPath,
+              visitedFiles,
+            );
+            if (result) return result;
+          }
+        }
+      }
+
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Checks if an import declaration imports a specific type.
+   * Handles named imports, default imports, and namespace imports.
+   */
+  private getImportedTypeFromDeclaration(
+    importDecl: ReturnType<SourceFile["getImportDeclarations"]>[0],
+    typeName: string,
+  ): boolean {
+    // Check named imports: import { Foo } from "..."
+    for (const namedImport of importDecl.getNamedImports()) {
+      const name =
+        namedImport.getAliasNode()?.getText() || namedImport.getName();
+      if (name === typeName) return true;
+    }
+
+    // Check default import: import Foo from "..."
+    const defaultImport = importDecl.getDefaultImport();
+    if (defaultImport?.getText() === typeName) return true;
+
+    // Check namespace import: import * as Foo from "..."
+    const namespaceImport = importDecl.getNamespaceImport();
+    if (namespaceImport?.getText() === typeName) return true;
+
+    return false;
+  }
+
+  /**
+   * Checks if a source file defines and exports a specific type.
+   * Handles interfaces, type aliases, classes, and re-exported types.
+   * Only returns true if the type is publicly exported.
+   */
+  private fileDefinesType(sourceFile: SourceFile, typeName: string): boolean {
+    // Check exported interfaces, type aliases, and classes
+    for (const decl of [
+      ...sourceFile.getInterfaces(),
+      ...sourceFile.getTypeAliases(),
+      ...sourceFile.getClasses(),
+    ]) {
+      if (decl.getName() === typeName && decl.isExported()) {
+        return true;
+      }
+    }
+
+    // Check exported types in export declarations (re-exports)
+    for (const exportDecl of sourceFile.getExportDeclarations()) {
+      for (const namedExport of exportDecl.getNamedExports()) {
+        if (namedExport.getName() === typeName) return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Resolves a relative import path to an actual file path.
+   * Handles TypeScript extensions and index files.
+   */
+  private resolveImportPath(
+    fromFile: string,
+    importPath: string,
+  ): string | null {
+    const dir = dirname(fromFile);
+    const extensions = [".ts", ".tsx", ".d.ts"];
+
+    // Try direct file with TS extensions
+    for (const ext of extensions) {
+      const fullPath = resolve(dir, `${importPath}${ext}`);
+      if (existsSync(fullPath)) return fullPath;
+    }
+
+    // Try index files
+    for (const ext of extensions) {
+      const fullPath = resolve(dir, `${importPath}/index${ext}`);
+      if (existsSync(fullPath)) return fullPath;
+    }
+
+    // Handle .js → .ts mapping
+    if (importPath.endsWith(".js")) {
+      const tsPath = resolve(dir, importPath.replace(/\.js$/, ".ts"));
+      if (existsSync(tsPath)) return tsPath;
+
+      const dtsPath = resolve(dir, importPath.replace(/\.js$/, ".d.ts"));
+      if (existsSync(dtsPath)) return dtsPath;
+    }
+
+    return null;
+  }
+
+  /**
+   * Get all types that were found to exist but are not exported.
+   * Call this after searching to get the list of types that need to be exported.
+   */
+  getUnexportedTypes(): UnexportedTypeLocation[] {
+    return Array.from(this.unexportedTypes.entries()).map(
+      ([typeName, filePath]) => ({
+        typeName,
+        filePath,
+      }),
+    );
+  }
+
+  /**
+   * Check if a file declares a type (regardless of export status).
+   * Used internally to track unexported types.
+   */
+  private fileHasTypeDeclaration(
+    sourceFile: SourceFile,
+    typeName: string,
+  ): { found: boolean; exported: boolean; filePath: string } {
+    const filePath = sourceFile.getFilePath();
+
+    // Check interfaces, type aliases, and classes
+    for (const decl of [
+      ...sourceFile.getInterfaces(),
+      ...sourceFile.getTypeAliases(),
+      ...sourceFile.getClasses(),
+    ]) {
+      if (decl.getName() === typeName) {
+        return {
+          found: true,
+          exported: decl.isExported(),
+          filePath,
+        };
+      }
+    }
+
+    return { found: false, exported: false, filePath };
+  }
+
+  /**
+   * Track an unexported type for later reporting.
+   */
+  private trackUnexportedType(typeName: string, filePath: string): void {
+    if (!this.unexportedTypes.has(typeName)) {
+      this.unexportedTypes.set(typeName, filePath);
+    }
+  }
+
+  /**
+   * Disposes of internal resources and clears caches.
+   * Should be called when the finder is no longer needed.
+   */
+  dispose(): void {
+    this.typeLocationCache.clear();
+    this.unexportedTypes.clear();
+    this.project = undefined;
+  }
+}

package/src/type-categorizer.ts

@@ -0,0 +1,131 @@
+import { TsMorphTypeDefinitionFinder } from "./ts-morph-type-finder";
+import {
+  isNodeModulesPath,
+  extractPackageNameFromPath,
+  createRelativeImportPath,
+} from "./path-utils";
+
+/**
+ * Categorized types for import generation.
+ * Types are split into three categories based on where they should be imported from.
+ */
+export interface TypeCategories {
+  /** Types defined in the same file as the main type (import from main source) */
+  localTypes: Set<string>;
+  /** Types from other local files, grouped by relative import path */
+  relativeImports: Map<string, Set<string>>;
+  /** Types from external packages (node_modules), mapped to package name */
+  externalTypes: Map<string, string>;
+}
+
+/**
+ * Options for type categorization.
+ */
+export interface CategorizerOptions {
+  /** The main source file being generated */
+  mainSourceFile: string;
+  /** Types known to be in the main source file (optional optimization) */
+  sameFileTypes?: Set<string>;
+}
+
+/**
+ * Categorizes referenced types into local, relative, and external imports.
+ *
+ * Uses TsMorphTypeDefinitionFinder to resolve where each type is defined, then
+ * categorizes based on the resolved path:
+ * - Same file as main → localTypes
+ * - Different local file → relativeImports
+ * - node_modules → externalTypes
+ *
+ * @param referencedTypes - Set of type names that need to be imported
+ * @param finder - TsMorphTypeDefinitionFinder instance for resolving type locations
+ * @param options - Categorization options including main source file
+ * @returns Categorized types for import generation
+ */
+export function categorizeTypes(
+  referencedTypes: Set<string>,
+  finder: TsMorphTypeDefinitionFinder,
+  options: CategorizerOptions,
+): TypeCategories {
+  const { mainSourceFile, sameFileTypes } = options;
+
+  const result: TypeCategories = {
+    localTypes: new Set(),
+    relativeImports: new Map(),
+    externalTypes: new Map(),
+  };
+
+  for (const typeName of referencedTypes) {
+    // Optimization: if we know the type is in the same file, skip resolution
+    if (sameFileTypes?.has(typeName)) {
+      result.localTypes.add(typeName);
+      continue;
+    }
+
+    // Try to resolve the type's source file
+    const sourceFile = finder.findTypeSourceFile(typeName, mainSourceFile);
+
+    if (!sourceFile) {
+      // Could not resolve - assume it's in the same file
+      result.localTypes.add(typeName);
+      continue;
+    }
+
+    // Normalize paths for comparison
+    const normalizedSource = normalizePath(sourceFile);
+    const normalizedMain = normalizePath(mainSourceFile);
+
+    if (normalizedSource === normalizedMain) {
+      // Same file
+      result.localTypes.add(typeName);
+    } else if (isNodeModulesPath(sourceFile)) {
+      // External package
+      const packageName = extractPackageNameFromPath(sourceFile);
+      if (packageName) {
+        result.externalTypes.set(typeName, packageName);
+      } else {
+        // Couldn't extract package name, fallback to local
+        result.localTypes.add(typeName);
+      }
+    } else {
+      // Different local file - create relative import path
+      const relativePath = createRelativeImportPath(mainSourceFile, sourceFile);
+      if (!result.relativeImports.has(relativePath)) {
+        result.relativeImports.set(relativePath, new Set());
+      }
+      result.relativeImports.get(relativePath)!.add(typeName);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Groups external types by their package name for import generation.
+ * This allows generating single imports per package with multiple types.
+ *
+ * @param externalTypes - Map of typeName → packageName
+ * @returns Map of packageName → Set of typeNames
+ */
+export function groupExternalTypesByPackage(
+  externalTypes: Map<string, string>,
+): Map<string, Set<string>> {
+  const grouped = new Map<string, Set<string>>();
+
+  for (const [typeName, packageName] of externalTypes) {
+    if (!grouped.has(packageName)) {
+      grouped.set(packageName, new Set());
+    }
+    grouped.get(packageName)!.add(typeName);
+  }
+
+  return grouped;
+}
+
+/**
+ * Normalizes a file path for comparison.
+ * Removes trailing slashes and normalizes separators.
+ */
+function normalizePath(filePath: string): string {
+  return filePath.replace(/\\/g, "/").replace(/\/$/, "");
+}