apisec-code-bolt 0.1.0__py3-none-any.whl

apisec_code_bolt/parsing/csharp/type_resolver.py

@@ -0,0 +1,568 @@
+"""
+C# cross-file type resolver with transitive inheritance.
+
+Implements the TypeResolver protocol for C# projects.
+
+Resolution order for a type name N seen in file F:
+  1. Direct qualified-name lookup  (``Namespace.ClassName``)
+  2. Generic stripping + retry     (``List<User>`` → ``User``)
+  3. Same-namespace implicit        (types in the same namespace as F)
+  4. ``using``-namespace scan       (``using Foo.Bar;`` → try ``Foo.Bar.N``)
+  5. Project-wide simple-name index (unambiguous cross-file fallback)
+
+Transitive inheritance:
+  ``all_ancestors`` is computed with BFS through the symbol table so that
+  ``is_subclass_of("Foo", "ControllerBase")`` works even when the chain spans
+  many files.  Results are cached to avoid quadratic re-traversal.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from ..base import ParsedClass, ParsedField
+from ..services import ResolvedField, ResolvedType
+
+if TYPE_CHECKING:
+    from ..base import ParsedFile
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# C#-specific constants
+# ---------------------------------------------------------------------------
+
+# Built-in and BCL types that are never in the project symbol table.
+_CS_BUILTINS: frozenset[str] = frozenset(
+    {
+        "string",
+        "int",
+        "long",
+        "double",
+        "float",
+        "bool",
+        "byte",
+        "short",
+        "char",
+        "decimal",
+        "object",
+        "void",
+        "var",
+        "dynamic",
+        "String",
+        "Int32",
+        "Int64",
+        "Int16",
+        "UInt32",
+        "UInt64",
+        "UInt16",
+        "Double",
+        "Single",
+        "Boolean",
+        "Byte",
+        "Char",
+        "Decimal",
+        "Object",
+        "Void",
+        "Guid",
+        "DateTime",
+        "DateTimeOffset",
+        "TimeSpan",
+        "Task",
+        "ValueTask",
+        "Thread",
+        "CancellationToken",
+        "IActionResult",
+        "ActionResult",
+        "IResult",
+        "Results",
+        "Ok",
+        "NotFound",
+        "BadRequest",
+        "Created",
+        "NoContent",
+        "List",
+        "IList",
+        "IEnumerable",
+        "ICollection",
+        "IReadOnlyList",
+        "IReadOnlyCollection",
+        "Dictionary",
+        "IDictionary",
+        "HashSet",
+        "ISet",
+        "Queue",
+        "Stack",
+        "Tuple",
+        "Nullable",
+        "Exception",
+        "ArgumentException",
+        "InvalidOperationException",
+        "NotImplementedException",
+        "NullReferenceException",
+        "HttpContext",
+        "HttpRequest",
+        "HttpResponse",
+        "ILogger",
+        "ILoggerFactory",
+        "IConfiguration",
+        "IServiceProvider",
+        "IServiceCollection",
+        "ClaimsPrincipal",
+        "Claim",
+        "ClaimsIdentity",
+        "JsonElement",
+        "JsonDocument",
+    }
+)
+
+# Single-parameter container types whose inner type is more useful to resolve.
+_SINGLE_PARAM_CONTAINERS: frozenset[str] = frozenset(
+    {
+        "Task",
+        "ValueTask",
+        "Nullable",
+        "Optional",
+        "Lazy",
+        "IEnumerable",
+        "IList",
+        "ICollection",
+        "IReadOnlyList",
+        "IReadOnlyCollection",
+        "ISet",
+        "List",
+        "HashSet",
+        "IActionResult",
+        "ActionResult",
+        "ResponseEntity",  # Spring (shouldn't appear in C# but harmless)
+        # Ardalis / Minimal API wrappers
+        "WithRequest",
+        "WithResponse",
+        "WithActionResult",
+    }
+)
+
+# Attributes that signal a data model / entity.
+_MODEL_ATTRIBUTES: frozenset[str] = frozenset(
+    {
+        "Table",
+        "Entity",
+        "Serializable",
+        "DataContract",
+        "JsonObject",  # Newtonsoft
+    }
+)
+
+# Naming conventions for DTO / view-model types.
+_MODEL_SUFFIXES: tuple[str, ...] = (
+    "Request",
+    "Response",
+    "Dto",
+    "DTO",
+    "ViewModel",
+    "Model",
+    "Input",
+    "Output",
+    "Payload",
+    "Body",
+    "Message",
+)
+
+# Base classes that indicate a data-model / value-object hierarchy.
+_MODEL_BASE_NAMES: frozenset[str] = frozenset(
+    {
+        "BaseEntity",
+        "Entity",
+        "ValueObject",
+        "AggregateRoot",
+        "AuditableEntity",
+        "DomainEvent",
+    }
+)
+
+# Base classes / attributes that indicate a controller (NOT a model).
+_CONTROLLER_BASES: frozenset[str] = frozenset(
+    {
+        "Controller",
+        "ControllerBase",
+        "ApiController",
+        "EndpointBaseAsync",
+        "PageModel",  # Razor Pages
+    }
+)
+
+# Regex to strip generic type arguments:  ``IEndpoint<T1, T2>`` → ``IEndpoint``
+_GENERIC_RE = re.compile(r"<[^<>]*(?:<[^<>]*>[^<>]*)?>")  # strips one nesting level
+
+
+def _strip_generics(name: str) -> str:
+    """Remove generic type arguments from a C# type name.
+
+    ``List<User>``            → ``List``
+    ``Task<ActionResult<T>>`` → ``Task``
+    ``IDictionary<K,V>``      → ``IDictionary``
+    """
+    return _GENERIC_RE.sub("", name).rstrip("<>").strip()
+
+
+def _unwrap_container(name: str) -> str | None:
+    """For single-param containers return the inner type; otherwise None.
+
+    ``Task<AuthenticateResponse>`` → ``AuthenticateResponse``
+    ``List<UserDto>``              → ``UserDto``
+    ``IDictionary<K,V>``           → ``None``  (multi-param, ambiguous)
+    """
+    m = re.match(r"^(\w+)<([^,>]+)>$", name.strip())
+    if not m:
+        return None
+    outer = m.group(1)
+    inner = m.group(2).strip()
+    if outer in _SINGLE_PARAM_CONTAINERS:
+        return inner
+    return None
+
+
+# ---------------------------------------------------------------------------
+# CSharpTypeResolver
+# ---------------------------------------------------------------------------
+
+
+class CSharpTypeResolver:
+    """
+    Cross-file type resolver for C# projects.
+
+    Builds an in-memory symbol table from all successfully parsed .cs files
+    and resolves types using C# namespace semantics.
+    """
+
+    def __init__(self, parsed_files: list[ParsedFile]) -> None:
+        # Qualified-name → ParsedClass  (primary symbol table)
+        self._symbol_table: dict[str, ParsedClass] = {}
+        # Simple name → list[qualified_name]  (for unambiguous fallback)
+        self._simple_name_index: dict[str, list[str]] = {}
+        # file → own namespace  (for same-namespace resolution)
+        self._file_namespace: dict[Path, str] = {}
+        # file → [imported namespaces]  (from `using` directives)
+        self._file_usings: dict[Path, list[str]] = {}
+        # namespace → [qualified_names]  (namespace membership index)
+        self._namespace_index: dict[str, list[str]] = {}
+        # Ancestor cache: qualified_name → [ancestor_qualified_names]
+        self._ancestor_cache: dict[str, list[str]] = {}
+
+        self._build(parsed_files)
+
+    # ------------------------------------------------------------------
+    # Build
+    # ------------------------------------------------------------------
+
+    def _build(self, parsed_files: list[ParsedFile]) -> None:
+        """Two-phase build: symbol table first, then import/using maps."""
+        # Phase 1 — symbol table + namespace index
+        for pf in parsed_files:
+            if not pf.success:
+                continue
+            for cls in pf.classes:
+                qname = cls.qualified_name.full
+                if not qname:
+                    continue
+                self._symbol_table[qname] = cls
+                self._simple_name_index.setdefault(cls.name, []).append(qname)
+
+                # Namespace membership
+                if "." in qname:
+                    ns = qname.rsplit(".", 1)[0]
+                    self._namespace_index.setdefault(ns, []).append(qname)
+
+        # Phase 2 — per-file using + namespace
+        for pf in parsed_files:
+            if not pf.success:
+                continue
+            usings: list[str] = []
+            ns = ""
+            for imp in pf.imports:
+                # C# `using Foo.Bar;` → module="Foo.Bar", names=[]
+                if imp.module and not imp.names:
+                    usings.append(imp.module)
+            # Infer own namespace from first class
+            for cls in pf.classes:
+                qn = cls.qualified_name.full
+                if "." in qn:
+                    ns = qn.rsplit(".", 1)[0]
+                    break
+            self._file_usings[pf.path] = usings
+            self._file_namespace[pf.path] = ns
+
+    # ------------------------------------------------------------------
+    # TypeResolver protocol
+    # ------------------------------------------------------------------
+
+    def resolve_type(
+        self,
+        name: str,
+        in_file: Path | None = None,
+    ) -> ResolvedType | None:
+        """Resolve a C# type name to its definition."""
+        if not name or name in _CS_BUILTINS:
+            return None
+
+        # Strip array and nullable suffixes
+        name = name.rstrip("[]?").strip()
+        if not name:
+            return None
+
+        # 1. Direct qualified-name lookup
+        if name in self._symbol_table:
+            return self._to_resolved_type(self._symbol_table[name])
+
+        # 2. Generic stripping + retry
+        stripped = _strip_generics(name)
+        if stripped != name and stripped:
+            result = self.resolve_type(stripped, in_file)
+            if result:
+                return result
+            # Also try unwrapping container to inner type
+            inner = _unwrap_container(name)
+            if inner:
+                result = self.resolve_type(inner, in_file)
+                if result:
+                    return result
+
+        # 3. Same-namespace implicit visibility
+        if in_file is not None:
+            own_ns = self._file_namespace.get(in_file, "")
+            if own_ns:
+                candidate = f"{own_ns}.{name}"
+                if candidate in self._symbol_table:
+                    return self._to_resolved_type(self._symbol_table[candidate])
+
+            # 4. using-namespace scan
+            for ns in self._file_usings.get(in_file, []):
+                candidate = f"{ns}.{name}"
+                if candidate in self._symbol_table:
+                    return self._to_resolved_type(self._symbol_table[candidate])
+
+        # 5. Project-wide simple-name index (unambiguous)
+        candidates = self._simple_name_index.get(name, [])
+        if len(candidates) == 1:
+            return self._to_resolved_type(self._symbol_table[candidates[0]])
+        if len(candidates) > 1:
+            logger.debug("Ambiguous C# type '%s': %s — using first", name, candidates)
+            return self._to_resolved_type(self._symbol_table[candidates[0]])
+
+        return None
+
+    def is_model_type(
+        self,
+        name: str,
+        in_file: Path | None = None,
+    ) -> bool:
+        resolved = self.resolve_type(name, in_file)
+        return resolved.is_model if resolved else False
+
+    def get_model_fields(
+        self,
+        model_name: str,
+        in_file: Path | None = None,
+        include_inherited: bool = True,
+    ) -> list[ResolvedField]:
+        resolved = self.resolve_type(model_name, in_file)
+        if resolved is None:
+            return []
+
+        fields: list[ResolvedField] = list(resolved.fields)
+
+        if include_inherited:
+            seen_names = {f.name for f in fields}
+            for ancestor_qname in resolved.all_ancestors:
+                ancestor_cls = self._symbol_table.get(ancestor_qname)
+                if ancestor_cls is None:
+                    # Try simple name
+                    candidates = self._simple_name_index.get(ancestor_qname, [])
+                    if candidates:
+                        ancestor_cls = self._symbol_table.get(candidates[0])
+                if ancestor_cls is None:
+                    continue
+                for f in ancestor_cls.fields:
+                    if getattr(f, "access_modifier", "public") != "public":
+                        continue
+                    if f.name not in seen_names:
+                        seen_names.add(f.name)
+                        fields.append(
+                            ResolvedField(
+                                name=f.name,
+                                type_annotation=f.type_annotation,
+                                default_value=f.default_value,
+                                is_required=f.default_value is None,
+                                constraints=self._constraints_from_decorators(f),
+                                defined_in_class=ancestor_cls.qualified_name.full,
+                            )
+                        )
+
+        return fields
+
+    def is_subclass_of(
+        self,
+        class_name: str,
+        base_name: str,
+        in_file: Path | None = None,
+    ) -> bool:
+        resolved = self.resolve_type(class_name, in_file)
+        if resolved is None:
+            return False
+        # Check direct bases and full ancestor list
+        if base_name in resolved.base_classes:
+            return True
+        return base_name in resolved.all_ancestors or any(
+            a.endswith(f".{base_name}") or a == base_name for a in resolved.all_ancestors
+        )
+
+    def get_all_models(self) -> dict[str, ResolvedType]:
+        result: dict[str, ResolvedType] = {}
+        for qname in self._symbol_table:
+            rt = self._to_resolved_type(self._symbol_table[qname])
+            if rt.is_model:
+                result[qname] = rt
+        return result
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _to_resolved_type(self, cls: ParsedClass) -> ResolvedType:
+        """Convert a ParsedClass to a ResolvedType with transitive ancestors."""
+        qname = cls.qualified_name.full
+        attr_names = {d.name for d in (cls.decorators or [])}
+
+        all_ancestors = self._collect_ancestors(qname, list(cls.base_classes))
+
+        # Only public fields count for model detection / are part of the API surface
+        public_fields = [
+            f for f in cls.fields if f.name and getattr(f, "access_modifier", "public") == "public"
+        ]
+
+        # Model detection: naming convention, attribute, base class, or field count
+        is_model = (
+            self._is_model_by_name(cls.name)
+            or bool(attr_names & _MODEL_ATTRIBUTES)
+            or any(
+                a in _MODEL_BASE_NAMES or any(a.endswith(f".{m}") for m in _MODEL_BASE_NAMES)
+                for a in [cls.name] + list(cls.base_classes) + all_ancestors
+            )
+            or (len(public_fields) >= 2 and not self._is_controller(cls, all_ancestors))
+        )
+
+        resolved_fields: list[ResolvedField] = [
+            ResolvedField(
+                name=f.name,
+                type_annotation=f.type_annotation,
+                default_value=f.default_value,
+                is_required=f.default_value is None,
+                constraints=self._constraints_from_decorators(f),
+                defined_in_class=qname,
+            )
+            for f in public_fields
+        ]
+
+        return ResolvedType(
+            name=cls.name,
+            qualified_name=qname,
+            file_path=Path(cls.location.file) if cls.location and cls.location.file else None,
+            is_class=True,
+            is_model=is_model,
+            is_enum=getattr(cls, "is_enum", False),
+            base_classes=list(cls.base_classes),
+            all_ancestors=all_ancestors,
+            fields=resolved_fields,
+            definition=cls,
+        )
+
+    @staticmethod
+    def _constraints_from_decorators(f: ParsedField) -> dict:
+        """Map C# data-annotation decorators to a constraints dict."""
+        if not f.decorators:
+            return {}
+        constraints: dict = {}
+        for dec in f.decorators:
+            name = dec.name
+            args = dec.positional_args or []
+            kw = dec.arguments or {}
+            if name == "Required":
+                constraints["required"] = True
+            elif name == "Range" and len(args) >= 2:
+                constraints["minimum"] = args[0]
+                constraints["maximum"] = args[1]
+            elif name == "MinLength" and args:
+                constraints["minLength"] = args[0]
+            elif name == "MaxLength" and args:
+                constraints["maxLength"] = args[0]
+            elif name == "StringLength" and args:
+                constraints["maxLength"] = args[0]
+                if "MinimumLength" in kw:
+                    constraints["minLength"] = kw["MinimumLength"]
+            elif name == "RegularExpression" and args:
+                constraints["pattern"] = args[0]
+            elif name == "EmailAddress":
+                constraints["format"] = "email"
+            elif name == "Url":
+                constraints["format"] = "uri"
+        return constraints
+
+    @staticmethod
+    def _is_model_by_name(name: str) -> bool:
+        return any(name.endswith(sfx) for sfx in _MODEL_SUFFIXES)
+
+    @staticmethod
+    def _is_controller(cls: ParsedClass, all_ancestors: list[str]) -> bool:
+        """Return True if this class is a controller / handler, not a DTO."""
+        if cls.name in _CONTROLLER_BASES:
+            return True
+        for base in list(cls.base_classes) + all_ancestors:
+            simple = base.rsplit(".", 1)[-1]
+            if simple in _CONTROLLER_BASES or base in _CONTROLLER_BASES:
+                return True
+        return False
+
+    def _collect_ancestors(self, qname: str, direct_bases: list[str]) -> list[str]:
+        """BFS through the symbol table to collect all transitive ancestors.
+
+        Results are cached by the starting class's qualified name.
+        """
+        if qname in self._ancestor_cache:
+            return list(self._ancestor_cache[qname])
+
+        ancestors: list[str] = []
+        seen: set[str] = {qname}
+        queue: list[str] = list(direct_bases)
+
+        while queue:
+            base = queue.pop(0)
+            if base in seen:
+                continue
+            seen.add(base)
+            ancestors.append(base)
+
+            # Resolve the base to its ParsedClass to continue the chain
+            base_cls = self._symbol_table.get(base)
+            if base_cls is None:
+                # Try simple-name index
+                candidates = self._simple_name_index.get(base, [])
+                if candidates:
+                    base_cls = self._symbol_table.get(candidates[0])
+                    if base_cls:
+                        # Replace simple name with qualified name in ancestors;
+                        # keep the original simple name in `seen` too so that
+                        # cyclic references via simple names don't re-enqueue.
+                        ancestors[-1] = candidates[0]
+                        seen.add(candidates[0])  # keep `base` (simple) in seen
+
+            if base_cls is not None:
+                for grandparent in base_cls.base_classes:
+                    if grandparent not in seen:
+                        queue.append(grandparent)
+
+        self._ancestor_cache[qname] = ancestors
+        return ancestors

apisec_code_bolt/parsing/js/__init__.py

@@ -0,0 +1,5 @@
+"""JavaScript/TypeScript parser."""
+
+from .parser import JavaScriptParser
+
+__all__ = ["JavaScriptParser"]

apisec_code_bolt/parsing/js/language_services.py

@@ -0,0 +1,118 @@
+"""
+JavaScript/TypeScript language services.
+
+No-op implementations of the TypeResolver, ConstantResolver, and PathResolver
+protocols. JavaScript/TypeScript does not yet have cross-file type resolution;
+these stubs satisfy the LanguageServices contract so the framework plugins
+(Express, NestJS) can receive an AnalysisContext.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from ..services import (
+    AnalysisContext,
+    LanguageServices,
+)
+
+if TYPE_CHECKING:
+    from ..base import ParsedFile
+
+
+class _NoOpTypeResolver:
+    """No-op TypeResolver for JavaScript — type resolution not yet implemented."""
+
+    def resolve_type(self, *a: Any, **kw: Any) -> None:
+        return None
+
+    def is_model_type(self, *a: Any, **kw: Any) -> bool:
+        return False
+
+    def get_model_fields(self, *a: Any, **kw: Any) -> list:
+        return []
+
+    def is_subclass_of(self, *a: Any, **kw: Any) -> bool:
+        return False
+
+    def get_all_models(self) -> dict:
+        return {}
+
+
+class _NoOpConstantResolver:
+    """No-op ConstantResolver for JavaScript."""
+
+    def resolve(self, *a: Any, **kw: Any) -> None:
+        return None
+
+    def resolve_value(self, *a: Any, **kw: Any) -> None:
+        return None
+
+    def get_all_constants(self) -> dict:
+        return {}
+
+
+class _NoOpPathResolver:
+    """No-op PathResolver for JavaScript."""
+
+    def resolve(self, *a: Any, **kw: Any) -> None:
+        return None
+
+    def get_all_constants(self) -> dict:
+        return {}
+
+
+class JavaScriptLanguageServices(LanguageServices):
+    """
+    LanguageServices factory for JavaScript/TypeScript.
+
+    Returns no-op resolvers. The framework plugins (Express, NestJS)
+    do not rely on cross-file type resolution — they work directly
+    from parsed call sites and decorator annotations.
+    """
+
+    def build_type_resolver(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> _NoOpTypeResolver:
+        return _NoOpTypeResolver()
+
+    def build_constant_resolver(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> _NoOpConstantResolver:
+        return _NoOpConstantResolver()
+
+    def build_path_resolver(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> _NoOpPathResolver:
+        return _NoOpPathResolver()
+
+    def build_framework_services(
+        self,
+        framework: str,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+    ) -> dict[str, Any]:
+        return {}
+
+    def build_context(
+        self,
+        parsed_files: list[ParsedFile],
+        project_root: Path | None = None,
+        framework: str | None = None,
+    ) -> AnalysisContext:
+        return AnalysisContext(
+            type_resolver=self.build_type_resolver(parsed_files, project_root),
+            constant_resolver=self.build_constant_resolver(parsed_files, project_root),
+            path_resolver=self.build_path_resolver(parsed_files, project_root),
+            router_registry=None,
+            project_root=project_root,
+            all_parsed_files=list(parsed_files),
+            language_services={},
+        )