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

package/src/type-collector.ts

@@ -0,0 +1,296 @@
+import type { NodeType, ObjectType, NamedType } from "@xlr-lib/xlr";
+import { isGenericNamedType } from "@xlr-lib/xlr-utils";
+import {
+  isObjectType,
+  isArrayType,
+  isRefType,
+  isOrType,
+  isAndType,
+  isNamedType,
+  isBuiltinType,
+  extractBaseName,
+  parseNamespacedType,
+  type TypeRegistry,
+} from "./utils";
+
+/**
+ * Interface for tracking type references.
+ * Implemented by the import generator to track types that need to be imported.
+ */
+export interface TypeTracker {
+  trackReferencedType(typeName: string): void;
+  trackNamespaceImport(namespaceName: string): void;
+}
+
+/**
+ * Collects type references from XLR types for import generation.
+ */
+export class TypeCollector {
+  private readonly typeTracker: TypeTracker;
+  private readonly genericParamSymbols: Set<string>;
+  private readonly mainTypeName: string;
+  private readonly namespaceMemberMap: Map<string, string>;
+  private readonly typeRegistry?: TypeRegistry;
+
+  constructor(
+    typeTracker: TypeTracker,
+    genericParamSymbols: Set<string>,
+    mainTypeName: string,
+    namespaceMemberMap: Map<string, string>,
+    typeRegistry?: TypeRegistry,
+  ) {
+    this.typeTracker = typeTracker;
+    this.genericParamSymbols = genericParamSymbols;
+    this.mainTypeName = mainTypeName;
+    this.namespaceMemberMap = namespaceMemberMap;
+    this.typeRegistry = typeRegistry;
+  }
+
+  /**
+   * Collect generic parameter symbols (e.g., T, U) from the type definition.
+   * These should not be imported as they are type parameters, not concrete types.
+   *
+   * Also handles the case where a non-generic type extends a generic base without
+   * passing type arguments. In that scenario, XLR copies properties from the base
+   * (including references to the base's generic params like `AnyAsset`) but does
+   * NOT propagate `genericTokens` to the child type. We scan the type registry for
+   * generic parameter symbols that should be excluded from imports.
+   */
+  collectGenericParamSymbols(namedType: NamedType<ObjectType>): void {
+    if (isGenericNamedType(namedType)) {
+      for (const token of namedType.genericTokens) {
+        this.genericParamSymbols.add(token.symbol);
+      }
+    }
+
+    // Scan the type registry for generic parameter symbols from other types.
+    // When XLR copies properties from a generic base without resolving generics,
+    // the property types still reference the base's generic parameter names
+    // (e.g., `AnyAsset` from `FileInputAssetBase<AnyAsset>`). These names are
+    // not concrete types and should not be imported. We collect them from all
+    // registry types, excluding any that are themselves registered as concrete types.
+    if (this.typeRegistry) {
+      for (const registeredType of this.typeRegistry.values()) {
+        if (isGenericNamedType(registeredType)) {
+          for (const token of registeredType.genericTokens) {
+            if (!this.typeRegistry.has(token.symbol)) {
+              this.genericParamSymbols.add(token.symbol);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Collect type references from generic parameter constraints and defaults.
+   * This ensures types used in generics like "T extends Foo = Bar<X>" have
+   * Foo, Bar, and X added to referencedTypes for import generation.
+   */
+  collectTypesFromGenericTokens(namedType: NamedType<ObjectType>): void {
+    if (!isGenericNamedType(namedType)) {
+      return;
+    }
+
+    for (const token of namedType.genericTokens) {
+      if (token.constraints) {
+        this.collectTypeReferencesFromNode(token.constraints);
+      }
+
+      if (token.default) {
+        this.collectTypeReferencesFromNode(token.default);
+      }
+    }
+  }
+
+  /**
+   * Collect all referenced types from an object type for imports.
+   */
+  collectReferencedTypes(objType: ObjectType): void {
+    for (const prop of Object.values(objType.properties)) {
+      this.collectReferencedTypesFromNode(prop.node);
+    }
+  }
+
+  /**
+   * Collect referenced types from a node type.
+   */
+  collectReferencedTypesFromNode(node: NodeType): void {
+    if (isObjectType(node)) {
+      if (isNamedType(node)) {
+        // Named types are defined elsewhere - track for import
+        // Skip built-in types and the type being generated
+        if (
+          node.name !== this.mainTypeName &&
+          !isBuiltinType(node.name) &&
+          !this.genericParamSymbols.has(node.name)
+        ) {
+          this.typeTracker.trackReferencedType(node.name);
+        }
+      } else {
+        // Anonymous object - recurse into properties to collect type references
+        for (const prop of Object.values(node.properties)) {
+          this.collectReferencedTypesFromNode(prop.node);
+        }
+      }
+    } else if (isArrayType(node)) {
+      this.collectReferencedTypesFromNode(node.elementType);
+    } else if (isOrType(node)) {
+      for (const variant of node.or) {
+        this.collectReferencedTypesFromNode(variant);
+      }
+    } else if (isAndType(node)) {
+      for (const part of node.and) {
+        this.collectReferencedTypesFromNode(part);
+      }
+    } else if (isRefType(node)) {
+      const baseName = extractBaseName(node.ref);
+
+      // Check if this is a namespaced type (e.g., "Validation.CrossfieldReference")
+      const namespaced = parseNamespacedType(baseName);
+      if (namespaced) {
+        // Track the namespace for import and the member mapping
+        this.typeTracker.trackNamespaceImport(namespaced.namespace);
+        this.namespaceMemberMap.set(namespaced.member, baseName);
+      } else {
+        // Track reference types that aren't built-in or generic params
+        if (
+          !isBuiltinType(baseName) &&
+          !this.genericParamSymbols.has(baseName)
+        ) {
+          this.typeTracker.trackReferencedType(baseName);
+        }
+      }
+
+      // Also process generic arguments, but skip type parameters of the referenced type
+      if (node.genericArguments) {
+        for (const arg of node.genericArguments) {
+          // Skip if this argument appears to be a type parameter of the referenced type
+          // e.g., in ref="Bar<AnyAsset>", skip "AnyAsset" since it's Bar's type param
+          if (isRefType(arg)) {
+            const argName = extractBaseName(arg.ref);
+            if (this.isTypeParamOfRef(argName, node.ref)) {
+              continue;
+            }
+          }
+          this.collectReferencedTypesFromNode(arg);
+        }
+      }
+    }
+  }
+
+  /**
+   * Recursively collect type references from any NodeType.
+   * This handles refs, arrays, unions, intersections, and objects.
+   */
+  private collectTypeReferencesFromNode(node: NodeType): void {
+    if (isRefType(node)) {
+      const baseName = extractBaseName(node.ref);
+
+      // Check if this is a namespaced type (e.g., "Validation.CrossfieldReference")
+      const namespaced = parseNamespacedType(baseName);
+      if (namespaced) {
+        // Track the namespace for import and the member mapping
+        this.typeTracker.trackNamespaceImport(namespaced.namespace);
+        this.namespaceMemberMap.set(namespaced.member, baseName);
+      } else if (
+        !isBuiltinType(baseName) &&
+        !this.genericParamSymbols.has(baseName)
+      ) {
+        // Skip built-in types and generic param symbols
+        this.typeTracker.trackReferencedType(baseName);
+      }
+
+      // Also process generic arguments, but skip type parameters of the referenced type
+      if (node.genericArguments) {
+        for (const arg of node.genericArguments) {
+          // Skip if this argument appears to be a type parameter of the referenced type
+          // e.g., in ref="Bar<AnyAsset>", skip "AnyAsset" since it's Bar's type param
+          if (isRefType(arg)) {
+            const argName = extractBaseName(arg.ref);
+            if (this.isTypeParamOfRef(argName, node.ref)) {
+              continue;
+            }
+          }
+          this.collectTypeReferencesFromNode(arg);
+        }
+      }
+    } else if (isArrayType(node)) {
+      this.collectTypeReferencesFromNode(node.elementType);
+    } else if (isOrType(node)) {
+      for (const variant of node.or) {
+        this.collectTypeReferencesFromNode(variant);
+      }
+    } else if (isAndType(node)) {
+      for (const part of node.and) {
+        this.collectTypeReferencesFromNode(part);
+      }
+    } else if (isObjectType(node)) {
+      if (isNamedType(node)) {
+        // Skip generic param symbols and built-in types in named types
+        // Strip generic arguments for import purposes
+        const importName = extractBaseName(node.name);
+        if (
+          !this.genericParamSymbols.has(importName) &&
+          !isBuiltinType(importName)
+        ) {
+          // Use trackReferencedType to properly resolve import path
+          this.typeTracker.trackReferencedType(importName);
+        }
+      }
+
+      for (const prop of Object.values(node.properties)) {
+        this.collectTypeReferencesFromNode(prop.node);
+      }
+    }
+  }
+
+  /**
+   * Check if a type name appears to be a generic type parameter of the referenced type.
+   * This detects cases like ref="Bar<AnyAsset>" where "AnyAsset" is Bar's type parameter,
+   * not a concrete type to import.
+   *
+   * @param argName - The name of the type argument being checked
+   * @param parentRef - The parent ref string that contains the generic usage
+   * @returns true if argName appears to be a type parameter in parentRef
+   */
+  private isTypeParamOfRef(argName: string, parentRef: string): boolean {
+    // Extract the generic parameters portion from the ref string
+    // e.g., "Bar<AnyAsset>" -> "AnyAsset", "Map<K, V>" -> "K, V"
+    const genericMatch = parentRef.match(/<(.+)>/);
+    if (!genericMatch) {
+      return false;
+    }
+
+    const genericPart = genericMatch[1];
+
+    // Split by comma while respecting nested generics
+    // and check if argName matches any parameter
+    let depth = 0;
+    let current = "";
+    const params: string[] = [];
+
+    for (const char of genericPart) {
+      if (char === "<") {
+        depth++;
+        current += char;
+      } else if (char === ">") {
+        depth--;
+        current += char;
+      } else if (char === "," && depth === 0) {
+        params.push(current.trim());
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+    if (current.trim()) {
+      params.push(current.trim());
+    }
+
+    // Check if argName matches any parameter exactly or is the base of a constrained param
+    return params.some(
+      (param) => param === argName || param.startsWith(`${argName} `),
+    );
+  }
+}

package/src/type-resolver.ts

@@ -0,0 +1,266 @@
+import ts from "typescript";
+import path from "node:path";
+import { TsMorphTypeDefinitionFinder } from "./ts-morph-type-finder";
+
+/**
+ * TypeScript context for automatic import resolution.
+ * When provided, the generator uses TypeScript's module resolution to determine
+ * where types should be imported from.
+ */
+export interface TypeScriptContext {
+  /** The TypeScript program */
+  program: ts.Program;
+  /** The source file containing the type being generated */
+  sourceFile: ts.SourceFile;
+  /** The output directory where generated files will be written */
+  outputDir: string;
+}
+
+/**
+ * Information about an unexported type that needs to be exported
+ */
+export interface UnexportedTypeInfo {
+  /** The type name that needs to be exported */
+  typeName: string;
+  /** The file path where the type is declared */
+  filePath: string;
+}
+
+/**
+ * Result from type resolution.
+ * - sameFile: type is defined in the same file as the main type
+ * - notFound: type couldn't be resolved anywhere
+ * - string: import path for the type (package name or relative path)
+ */
+export type TypeResolutionResult = "sameFile" | "notFound" | string;
+
+/**
+ * Check if a file path is a TypeScript lib/built-in declaration file.
+ * These are files like lib.dom.d.ts that contain built-in type definitions.
+ */
+export function isBuiltInDeclarationPath(filePath: string): boolean {
+  // TypeScript lib files
+  if (filePath.includes("/typescript/lib/lib.")) return true;
+  // Node.js built-in types
+  if (filePath.includes("/@types/node/")) return true;
+  return false;
+}
+
+/**
+ * Check if a declaration node is exported.
+ */
+export function isDeclarationExported(
+  node: ts.Declaration,
+  typescript: typeof ts,
+): boolean {
+  // Check for export modifier on the declaration itself
+  const modifiers = typescript.canHaveModifiers(node)
+    ? typescript.getModifiers(node)
+    : undefined;
+  if (modifiers) {
+    for (const modifier of modifiers) {
+      if (modifier.kind === typescript.SyntaxKind.ExportKeyword) {
+        return true;
+      }
+    }
+  }
+
+  // Check if this declaration is part of an export statement
+  const parent = node.parent;
+  if (parent && typescript.isExportDeclaration(parent)) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Creates an import resolver using TypeScript's type checker and
+ * TsMorphTypeDefinitionFinder for tracing types through imports.
+ * This handles cases where types come through extends, Pick, re-exports, etc.
+ */
+export function createTypeScriptResolver(tsContext: TypeScriptContext): {
+  resolveTypePath: (typeName: string) => TypeResolutionResult;
+  getUnexportedTypes: () => UnexportedTypeInfo[];
+} {
+  const { program, sourceFile, outputDir } = tsContext;
+  const typeChecker = program.getTypeChecker();
+
+  // Create the type definition finder for recursive search
+  const finder = new TsMorphTypeDefinitionFinder();
+
+  // Cache resolved paths
+  const resolvedCache = new Map<string, TypeResolutionResult>();
+
+  // Track types that exist but aren't exported
+  const unexportedTypes: UnexportedTypeInfo[] = [];
+
+  /**
+   * Resolve a type name to its import path.
+   * Returns:
+   * - "sameFile": type is in the same file as the source
+   * - "notFound": type couldn't be resolved anywhere
+   * - string (import path): type should be imported from this path
+   */
+  function resolveTypePath(typeName: string): TypeResolutionResult {
+    if (resolvedCache.has(typeName)) {
+      return resolvedCache.get(typeName)!;
+    }
+
+    // First, try to find the type using TsMorphTypeDefinitionFinder
+    // This recursively searches through imports
+    const typeFilePath = finder.findTypeSourceFile(
+      typeName,
+      sourceFile.fileName,
+    );
+
+    if (typeFilePath) {
+      // Check if it's from the same file
+      if (typeFilePath === sourceFile.fileName) {
+        resolvedCache.set(typeName, "sameFile");
+        return "sameFile";
+      }
+
+      // Check if it's a built-in declaration
+      if (isBuiltInDeclarationPath(typeFilePath)) {
+        resolvedCache.set(typeName, "sameFile");
+        return "sameFile";
+      }
+
+      // Check if it's from node_modules (external package)
+      if (typeFilePath.includes("node_modules")) {
+        const nodeModulesIdx = typeFilePath.lastIndexOf("node_modules/");
+        const afterNodeModules = typeFilePath.slice(
+          nodeModulesIdx + "node_modules/".length,
+        );
+
+        // Handle scoped packages (@scope/package)
+        let packageName: string;
+        if (afterNodeModules.startsWith("@")) {
+          const parts = afterNodeModules.split("/");
+          packageName = `${parts[0]}/${parts[1]}`;
+        } else {
+          packageName = afterNodeModules.split("/")[0];
+        }
+
+        resolvedCache.set(typeName, packageName);
+        return packageName;
+      }
+
+      // It's a local file - compute relative path from outputDir
+      let relativePath = path.relative(outputDir, typeFilePath);
+      relativePath = relativePath.replace(/\.tsx?$/, ".js");
+      if (!relativePath.startsWith(".")) {
+        relativePath = "./" + relativePath;
+      }
+
+      resolvedCache.set(typeName, relativePath);
+      return relativePath;
+    }
+
+    // If TsMorphTypeDefinitionFinder didn't find it, fall back to symbol resolution
+    // This handles cases where types are in scope but not through imports
+    const symbols = typeChecker.getSymbolsInScope(
+      sourceFile,
+      ts.SymbolFlags.Type | ts.SymbolFlags.Interface | ts.SymbolFlags.TypeAlias,
+    );
+
+    const matchingSymbols = symbols.filter((s) => s.getName() === typeName);
+
+    let symbol: ts.Symbol | undefined;
+    let validDeclaration: ts.Declaration | undefined;
+    let unexportedDeclarationFile: string | undefined;
+
+    for (const s of matchingSymbols) {
+      const declarations = s.getDeclarations();
+      if (declarations && declarations.length > 0) {
+        const decl = declarations[0];
+        const declFile = decl.getSourceFile().fileName;
+
+        // Skip built-in declarations
+        if (isBuiltInDeclarationPath(declFile)) {
+          continue;
+        }
+
+        // Check if the declaration is exported (has export modifier or is in node_modules)
+        const isFromNodeModules = declFile.includes("node_modules");
+        const isExported = isFromNodeModules || isDeclarationExported(decl, ts);
+
+        if (isExported) {
+          symbol = s;
+          validDeclaration = decl;
+          break;
+        } else {
+          // Track unexported declaration for warning
+          unexportedDeclarationFile = declFile;
+        }
+      }
+    }
+
+    if (!symbol || !validDeclaration) {
+      // Type exists but is not exported - track for warning
+      if (unexportedDeclarationFile) {
+        // Check if we already tracked this type
+        const alreadyTracked = unexportedTypes.some(
+          (t) =>
+            t.typeName === typeName && t.filePath === unexportedDeclarationFile,
+        );
+        if (!alreadyTracked) {
+          unexportedTypes.push({
+            typeName,
+            filePath: unexportedDeclarationFile,
+          });
+        }
+        // Type exists but isn't exported - treat as "not found" for import purposes
+        // It will be added to the same-file import, which will cause a type error,
+        // but the warning system will tell users what to export
+        resolvedCache.set(typeName, "sameFile");
+        return "sameFile";
+      }
+      // Type truly not found
+      resolvedCache.set(typeName, "notFound");
+      return "notFound";
+    }
+
+    const declSourceFile = validDeclaration.getSourceFile();
+    const declFilePath = declSourceFile.fileName;
+
+    if (declFilePath === sourceFile.fileName) {
+      resolvedCache.set(typeName, "sameFile");
+      return "sameFile";
+    }
+
+    if (declFilePath.includes("node_modules")) {
+      const nodeModulesIdx = declFilePath.lastIndexOf("node_modules/");
+      const afterNodeModules = declFilePath.slice(
+        nodeModulesIdx + "node_modules/".length,
+      );
+
+      let packageName: string;
+      if (afterNodeModules.startsWith("@")) {
+        const parts = afterNodeModules.split("/");
+        packageName = `${parts[0]}/${parts[1]}`;
+      } else {
+        packageName = afterNodeModules.split("/")[0];
+      }
+
+      resolvedCache.set(typeName, packageName);
+      return packageName;
+    }
+
+    let relativePath = path.relative(outputDir, declFilePath);
+    relativePath = relativePath.replace(/\.tsx?$/, ".js");
+    if (!relativePath.startsWith(".")) {
+      relativePath = "./" + relativePath;
+    }
+
+    resolvedCache.set(typeName, relativePath);
+    return relativePath;
+  }
+
+  function getUnexportedTypes(): UnexportedTypeInfo[] {
+    return [...unexportedTypes];
+  }
+
+  return { resolveTypePath, getUnexportedTypes };
+}