[CG-8705] feat: Implement Namespace as TS graph node type

src/codegen/sdk/core/expressions/chained_attribute.py

@@ -38,12 +38,12 @@
 
     def __init__(self, ts_node, file_node_id, ctx, parent: Parent, object: TSNode, attribute: TSNode):
         super().__init__(ts_node, file_node_id, ctx, parent=parent)
         self._object = self._parse_expression(object, default=Name)
         if self.ctx.parser._should_log:
             if not isinstance(self._object, Chainable):
                 msg = f"{self._object.__class__} is not chainable: {self._object.source}\nfile: {self.filepath}"
                 raise ValueError(msg)
         self._attribute = self._parse_expression(attribute, default=Name)
         if self.ctx.parser._should_log:
             if not isinstance(self._attribute, Resolvable):
                 msg = f"{self._attribute.__class__} is not resolvable: {self._attribute.source}\nfile: {self.filepath}"
@@ -89,12 +89,12 @@
         """
         from codegen.sdk.core.detached_symbols.function_call import FunctionCall
 
         ret = []
         curr = self
 
         # Traverse backwards in code (children of tree node)
         while isinstance(curr, ChainedAttribute):
             curr = curr.object
 
             if isinstance(curr, FunctionCall):
                 ret.insert(0, curr)
@@ -134,19 +134,16 @@
     @noapidoc
     @override
     def _resolved_types(self) -> Generator[ResolutionStack[Self], None, None]:
-        from codegen.sdk.typescript.namespace import TSNamespace
-
         if not self.ctx.config.method_usages:
             return
         if res := self.file.valid_import_names.get(self.full_name, None):
             # Module imports
             yield from self.with_resolution_frame(res)
             return
-        # HACK: This is a hack to skip the resolved types for namespaces
-        if isinstance(self.object, TSNamespace):
-            return
+
         for resolved_type in self.object.resolved_type_frames:
             top = resolved_type.top
+
             if not isinstance(top.node, HasAttribute):
                 generics: dict = resolved_type.generics.copy()
                 if top.node.source.lower() == "dict" and self.attribute.source in ("values", "get", "pop"):
@@ -160,14 +157,14 @@
                 yield from self.with_resolution_frame(attr, chained=True, generics=resolved_type.generics)
             else:
                 self._log_parse("Couldn't resolve attribute %s on %s", name, top.node)
                 yield from self.with_resolution_frame(top.node, direct=resolved_type.is_direct_usage, chained=True)
 
     @noapidoc
     @commiter
     def _compute_dependencies(self, usage_type: UsageKind, dest: Optional["HasName | None"] = None) -> None:
         edges = []
         for used_frame in self.resolved_type_frames:
             edges.extend(used_frame.get_edges(self, usage_type, dest, self.ctx))
         edges = list(dict.fromkeys(edges))
         self.ctx.add_edges(edges)
         if self.object.source not in ("self", "this"):

src/codegen/sdk/python/import_resolution.py

@@ -15,12 +15,12 @@
     from tree_sitter import Node as TSNode
 
     from codegen.sdk.codebase.codebase_context import CodebaseContext
+    from codegen.sdk.core.file import SourceFile
     from codegen.sdk.core.interfaces.editable import Editable
     from codegen.sdk.core.interfaces.exportable import Exportable
     from codegen.sdk.core.node_id_factory import NodeId
     from codegen.sdk.core.statements.import_statement import ImportStatement
     from codegen.sdk.python.file import PyFile
-    from src.codegen.sdk.core.file import SourceFile
 
 
 logger = get_logger(__name__)

src/codegen/sdk/typescript/import_resolution.py

@@ -8,7 +8,7 @@
 from codegen.sdk.core.expressions import Name
 from codegen.sdk.core.import_resolution import Import, ImportResolution, WildcardImport
 from codegen.sdk.core.interfaces.exportable import Exportable
-from codegen.sdk.enums import ImportType, NodeType
+from codegen.sdk.enums import ImportType, NodeType, SymbolType
 from codegen.sdk.utils import find_all_descendants, find_first_ancestor, find_first_descendant
 from codegen.shared.decorators.docs import noapidoc, ts_apidoc
 
@@ -24,6 +24,7 @@
     from codegen.sdk.core.statements.import_statement import ImportStatement
     from codegen.sdk.core.symbol import Symbol
     from codegen.sdk.typescript.file import TSFile
+    from codegen.sdk.typescript.namespace import TSNamespace
     from codegen.sdk.typescript.statements.import_statement import TSImportStatement
 
 
@@ -51,7 +52,7 @@
             while call_node.parent and call_node.parent.type in ["await_expression", "parenthesized_expression"]:
                 call_node = call_node.parent
             sibling = call_node.next_named_sibling
             return sibling and sibling.type == "property_identifier"
         return False
 
     @reader
@@ -122,7 +123,7 @@
             return []
 
         if not self.is_module_import():
             return [] if self.imported_symbol.export is None else [self.imported_symbol.export]
 
         from_file = self.imported_symbol
         if from_file.node_type != NodeType.FILE:
@@ -578,6 +579,48 @@
             return
         yield from super().names
 
+    @property
+    def namespace_imports(self) -> list[TSNamespace]:
+        """Returns any namespace objects imported by this import statement.
+
+        For example:
+        import * as MyNS from './mymodule';
+
+        Returns:
+            List of namespace objects imported
+        """
+        if not self.is_namespace_import():
+            return []
+
+        from codegen.sdk.typescript.namespace import TSNamespace
+
+        resolved = self.resolved_symbol
+        if resolved is None or not isinstance(resolved, TSNamespace):
+            return []
+
+        return [resolved]
+
+    @property
+    def is_namespace_import(self) -> bool:
+        """Returns True if this import is importing a namespace.
+
+        Examples:
+            import { MathUtils } from './file1';  # True if MathUtils is a namespace
+            import * as AllUtils from './utils';   # True
+        """
+        # For wildcard imports with namespace alias
+        if self.import_type == ImportType.WILDCARD and self.namespace:
+            return True
+
+        # For named imports, check if any imported symbol is a namespace
+        if self.import_type == ImportType.NAMED_EXPORT:
+            for name, _ in self.names:
+                symbol = self.resolved_symbol
+                if symbol and symbol.symbol_type == SymbolType.Namespace:
+                    return True
+
+        return False
+
     @override
     def set_import_module(self, new_module: str) -> None:
         """Sets the module of an import.