osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/java/jaxrs.py

@@ -0,0 +1,160 @@
+"""JAX-RS REST endpoint detector for Java source files."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_PATH_RE = re.compile(r'@Path\s*\(\s*"([^"]*)"')
+_HTTP_METHOD_RE = re.compile(r"@(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)\b")
+_PRODUCES_RE = re.compile(r'@Produces\s*\(\s*\{?\s*(?:MediaType\.\w+|"([^"]*)")')
+_CONSUMES_RE = re.compile(r'@Consumes\s*\(\s*\{?\s*(?:MediaType\.\w+|"([^"]*)")')
+_CLASS_RE = re.compile(r"(?:public\s+)?class\s+(\w+)")
+_JAVA_METHOD_RE = re.compile(
+    r'(?:public|protected|private)?\s*(?:static\s+)?(?:[\w<>\[\],\s]+)\s+(\w+)\s*\('
+)
+
+
+class JaxrsDetector:
+    """Detects JAX-RS REST endpoints from annotations."""
+
+    name: str = "jaxrs"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Fast bail
+        if "@Path" not in text and "javax.ws.rs" not in text and "jakarta.ws.rs" not in text:
+            return result
+
+        lines = text.split("\n")
+
+        # Find class name and class-level @Path
+        class_name: str | None = None
+        class_base_path = ""
+        for i, line in enumerate(lines):
+            cm = _CLASS_RE.search(line)
+            if cm:
+                class_name = cm.group(1)
+                # Look backwards for class-level @Path
+                for j in range(max(0, i - 5), i):
+                    pm = _PATH_RE.search(lines[j])
+                    if pm:
+                        class_base_path = pm.group(1).rstrip("/")
+                        break
+                break
+
+        if not class_name:
+            return result
+
+        class_node_id = f"{ctx.file_path}:{class_name}"
+
+        # Scan for method-level HTTP annotations
+        for i, line in enumerate(lines):
+            m = _HTTP_METHOD_RE.search(line)
+            if not m:
+                continue
+
+            http_method = m.group(1)
+
+            # Check whether this annotation is at the class level by
+            # inspecting the subsequent non-empty, non-annotation lines.
+            is_class_level = False
+            for k in range(i + 1, min(i + 5, len(lines))):
+                stripped = lines[k].strip()
+                if stripped.startswith("@") or not stripped:
+                    continue
+                if "class " in stripped or "interface " in stripped:
+                    is_class_level = True
+                break
+            if is_class_level:
+                continue
+
+            # Look for a nearby method-level @Path (within a few lines before
+            # and after the HTTP annotation)
+            method_path: str | None = None
+            for k in range(max(0, i - 3), min(i + 4, len(lines))):
+                if k == i:
+                    continue
+                pm = _PATH_RE.search(lines[k])
+                if pm:
+                    method_path = pm.group(1)
+                    break
+
+            # Combine class base path with method path
+            if method_path is not None:
+                full_path = f"{class_base_path}/{method_path.lstrip('/')}"
+            else:
+                full_path = class_base_path or "/"
+            if not full_path.startswith("/"):
+                full_path = "/" + full_path
+
+            # Extract @Produces and @Consumes near the annotation
+            produces: str | None = None
+            consumes: str | None = None
+            for k in range(max(0, i - 5), min(i + 5, len(lines))):
+                if produces is None:
+                    pm = _PRODUCES_RE.search(lines[k])
+                    if pm:
+                        produces = pm.group(1)  # may be None for MediaType constant
+                if consumes is None:
+                    cm = _CONSUMES_RE.search(lines[k])
+                    if cm:
+                        consumes = cm.group(1)  # may be None for MediaType constant
+
+            # Find the method name on subsequent lines
+            method_name: str | None = None
+            for k in range(i + 1, min(i + 5, len(lines))):
+                mm = _JAVA_METHOD_RE.search(lines[k])
+                if mm:
+                    method_name = mm.group(1)
+                    break
+
+            endpoint_label = f"{http_method} {full_path}"
+            endpoint_id = (
+                f"{ctx.file_path}:{class_name}:{method_name or 'unknown'}"
+                f":{http_method}:{full_path}"
+            )
+
+            properties: dict[str, Any] = {
+                "http_method": http_method,
+                "path": full_path,
+            }
+            if produces:
+                properties["produces"] = produces
+            if consumes:
+                properties["consumes"] = consumes
+
+            node = GraphNode(
+                id=endpoint_id,
+                kind=NodeKind.ENDPOINT,
+                label=endpoint_label,
+                fqn=f"{class_name}.{method_name}" if method_name else class_name,
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=i + 1),
+                annotations=[f"@{http_method}"],
+                properties=properties,
+            )
+            result.nodes.append(node)
+
+            edge = GraphEdge(
+                source=class_node_id,
+                target=endpoint_id,
+                kind=EdgeKind.EXPOSES,
+                label=f"{class_name} exposes {endpoint_label}",
+            )
+            result.edges.append(edge)
+
+        return result

osscodeiq/detectors/java/jdbc.py

@@ -0,0 +1,196 @@
+"""JDBC/ODBC database connectivity detector for Java source files."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_CLASS_RE = re.compile(r"(?:public\s+)?class\s+(\w+)")
+
+# DriverManager.getConnection("jdbc:...")
+_DRIVER_MANAGER_RE = re.compile(
+    r'DriverManager\s*\.\s*getConnection\s*\(\s*"(jdbc:[^"]+)"'
+)
+
+# JdbcTemplate / NamedParameterJdbcTemplate / JdbcClient field or constructor usage
+_JDBC_TEMPLATE_RE = re.compile(
+    r"(?:private|protected|public|final|\s)+"
+    r"(?:final\s+)?"
+    r"(JdbcTemplate|NamedParameterJdbcTemplate|JdbcClient)"
+    r"\s+\w+"
+)
+
+# DataSource bean definitions or annotations
+_DATASOURCE_BEAN_RE = re.compile(
+    r"(?:@Bean|DataSource)\s*(?:\(|\.)"
+)
+
+# spring.datasource.url property
+_SPRING_DATASOURCE_RE = re.compile(
+    r"spring\.datasource\.url\s*=\s*(jdbc:[^\s]+)"
+)
+
+# Generic JDBC URL pattern (captures db type and host info)
+_JDBC_URL_RE = re.compile(
+    r"jdbc:(mysql|postgresql|sqlserver|oracle|db2|h2|sqlite|mariadb)"
+    r"(?::(?:thin:)?(?:@)?)?(?://([^/\"'\s;?]+))?"
+)
+
+
+def _parse_jdbc_url(url: str) -> dict[str, str]:
+    """Extract db_type and host from a JDBC URL."""
+    props: dict[str, str] = {"connection_url": url}
+    m = _JDBC_URL_RE.search(url)
+    if m:
+        props["db_type"] = m.group(1)
+        if m.group(2):
+            props["host"] = m.group(2)
+    return props
+
+
+class JdbcDetector:
+    """Detects Java database connectivity patterns (JDBC, JdbcTemplate, DataSource)."""
+
+    name: str = "jdbc"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Fast-bail
+        if (
+            "JdbcTemplate" not in text
+            and "DriverManager" not in text
+            and "DataSource" not in text
+            and "NamedParameterJdbcTemplate" not in text
+            and "JdbcClient" not in text
+        ):
+            return result
+
+        lines = text.split("\n")
+
+        # Find class name
+        class_name: str | None = None
+        for line in lines:
+            cm = _CLASS_RE.search(line)
+            if cm:
+                class_name = cm.group(1)
+                break
+
+        if not class_name:
+            return result
+
+        class_node_id = f"{ctx.file_path}:{class_name}"
+        seen_dbs: set[str] = set()
+
+        def _ensure_db_node(
+            db_id: str,
+            label: str,
+            line_num: int | None,
+            properties: dict[str, Any],
+        ) -> str:
+            if db_id not in seen_dbs:
+                seen_dbs.add(db_id)
+                result.nodes.append(GraphNode(
+                    id=db_id,
+                    kind=NodeKind.DATABASE_CONNECTION,
+                    label=label,
+                    module=ctx.module_name,
+                    location=SourceLocation(
+                        file_path=ctx.file_path,
+                        line_start=line_num,
+                    ) if line_num else None,
+                    properties=properties,
+                ))
+            return db_id
+
+        def _add_connect_edge(db_id: str, label: str) -> None:
+            result.edges.append(GraphEdge(
+                source=class_node_id,
+                target=db_id,
+                kind=EdgeKind.CONNECTS_TO,
+                label=label,
+            ))
+
+        # Pattern 1: DriverManager.getConnection("jdbc:...")
+        for i, line in enumerate(lines):
+            m = _DRIVER_MANAGER_RE.search(line)
+            if not m:
+                continue
+            url = m.group(1)
+            props = _parse_jdbc_url(url)
+            db_type = props.get("db_type", "unknown")
+            host = props.get("host", "unknown")
+            db_id = f"db:{db_type}:{host}"
+            _ensure_db_node(db_id, f"{db_type}@{host}", i + 1, props)
+            _add_connect_edge(db_id, f"{class_name} connects to {db_type}@{host}")
+
+        # Pattern 2: JdbcTemplate / NamedParameterJdbcTemplate / JdbcClient usage
+        for i, line in enumerate(lines):
+            m = _JDBC_TEMPLATE_RE.search(line)
+            if not m:
+                continue
+            template_type = m.group(1)
+            db_id = f"{ctx.file_path}:jdbc:{class_name}"
+            _ensure_db_node(
+                db_id,
+                f"{class_name} ({template_type})",
+                i + 1,
+                {"template_type": template_type},
+            )
+            _add_connect_edge(db_id, f"{class_name} uses {template_type}")
+
+        # Pattern 3: DataSource bean definitions
+        for i, line in enumerate(lines):
+            m = _DATASOURCE_BEAN_RE.search(line)
+            if not m:
+                continue
+            db_id = f"{ctx.file_path}:jdbc:{class_name}"
+            _ensure_db_node(
+                db_id,
+                f"{class_name} (DataSource)",
+                i + 1,
+                {"datasource": True},
+            )
+
+        # Pattern 4: spring.datasource.url in properties content
+        if "spring.datasource" in text:
+            for i, line in enumerate(lines):
+                m = _SPRING_DATASOURCE_RE.search(line)
+                if not m:
+                    continue
+                url = m.group(1)
+                props = _parse_jdbc_url(url)
+                db_type = props.get("db_type", "unknown")
+                host = props.get("host", "unknown")
+                db_id = f"db:{db_type}:{host}"
+                _ensure_db_node(db_id, f"{db_type}@{host}", i + 1, props)
+
+        # Pattern 5: Standalone JDBC URL strings (not already caught above)
+        for i, line in enumerate(lines):
+            # Skip lines already matched by DriverManager or spring.datasource
+            if "DriverManager" in line or "spring.datasource" in line:
+                continue
+            urls = re.findall(r'"(jdbc:[^"]+)"', line)
+            for url in urls:
+                props = _parse_jdbc_url(url)
+                db_type = props.get("db_type", "unknown")
+                host = props.get("host", "unknown")
+                db_id = f"db:{db_type}:{host}"
+                _ensure_db_node(db_id, f"{db_type}@{host}", i + 1, props)
+                _add_connect_edge(
+                    db_id, f"{class_name} connects to {db_type}@{host}"
+                )
+
+        return result

osscodeiq/detectors/java/jms.py

@@ -0,0 +1,116 @@
+"""JMS (Java Message Service) detector for Java source files."""
+
+from __future__ import annotations
+
+import re
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_CLASS_RE = re.compile(r"(?:public\s+)?class\s+(\w+)")
+
+# JMS listener annotation
+_JMS_LISTENER_RE = re.compile(
+    r'@JmsListener\s*\(\s*(?:.*?destination\s*=\s*)?"([^"]+)"'
+)
+
+# JmsTemplate.send / convertAndSend
+_JMS_SEND_RE = re.compile(
+    r'(?:jmsTemplate|JmsTemplate)\s*\.(?:send|convertAndSend)\s*\(\s*"([^"]+)"'
+)
+
+# JmsTemplate with destination bean
+_JMS_DEST_RE = re.compile(
+    r'(?:ActiveMQQueue|ActiveMQTopic)\s*\(\s*"([^"]+)"'
+)
+
+_CONTAINER_FACTORY_RE = re.compile(r'containerFactory\s*=\s*"([^"]+)"')
+
+
+class JmsDetector:
+    """Detects JMS consumers and producers."""
+
+    name: str = "jms"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        if "@JmsListener" not in text and "jmsTemplate" not in text and "JmsTemplate" not in text:
+            return result
+
+        # Find class name
+        class_name: str | None = None
+        for line in lines:
+            cm = _CLASS_RE.search(line)
+            if cm:
+                class_name = cm.group(1)
+                break
+
+        if not class_name:
+            return result
+
+        class_node_id = f"{ctx.file_path}:{class_name}"
+        seen_queues: set[str] = set()
+
+        def _ensure_queue_node(destination: str) -> str:
+            queue_id = f"jms:queue:{destination}"
+            if destination not in seen_queues:
+                seen_queues.add(destination)
+                result.nodes.append(GraphNode(
+                    id=queue_id,
+                    kind=NodeKind.QUEUE,
+                    label=f"jms:{destination}",
+                    properties={"broker": "jms", "destination": destination},
+                ))
+            return queue_id
+
+        # Detect @JmsListener consumers
+        for i, line in enumerate(lines):
+            m = _JMS_LISTENER_RE.search(line)
+            if not m:
+                continue
+
+            destination = m.group(1)
+            queue_id = _ensure_queue_node(destination)
+
+            props: dict[str, str] = {"destination": destination}
+            cf = _CONTAINER_FACTORY_RE.search(line)
+            if cf:
+                props["container_factory"] = cf.group(1)
+
+            result.edges.append(GraphEdge(
+                source=class_node_id,
+                target=queue_id,
+                kind=EdgeKind.CONSUMES,
+                label=f"{class_name} consumes from {destination}",
+                properties=props,
+            ))
+
+        # Detect JmsTemplate sends
+        for i, line in enumerate(lines):
+            m = _JMS_SEND_RE.search(line)
+            if not m:
+                continue
+
+            destination = m.group(1)
+            queue_id = _ensure_queue_node(destination)
+
+            result.edges.append(GraphEdge(
+                source=class_node_id,
+                target=queue_id,
+                kind=EdgeKind.PRODUCES,
+                label=f"{class_name} produces to {destination}",
+                properties={"destination": destination},
+            ))
+
+        return result

osscodeiq/detectors/java/jpa_entity.py

@@ -0,0 +1,143 @@
+"""JPA entity detector for Java source files."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from osscodeiq.detectors.base import DetectorContext, DetectorResult
+from osscodeiq.detectors.utils import decode_text
+from osscodeiq.models.graph import (
+    EdgeKind,
+    GraphEdge,
+    GraphNode,
+    NodeKind,
+    SourceLocation,
+)
+
+_ENTITY_RE = re.compile(r"@Entity")
+_TABLE_RE = re.compile(r'@Table\s*\(\s*(?:name\s*=\s*)?"(\w+)"')
+_CLASS_RE = re.compile(r"(?:public\s+)?class\s+(\w+)")
+_COLUMN_RE = re.compile(r'@Column\s*\(([^)]*)\)')
+_COLUMN_NAME_RE = re.compile(r'name\s*=\s*"(\w+)"')
+_FIELD_RE = re.compile(r"(?:private|protected|public)\s+([\w<>,\s]+)\s+(\w+)\s*[;=]")
+
+_RELATIONSHIP_ANNOTATIONS = {
+    "OneToMany": "one_to_many",
+    "ManyToOne": "many_to_one",
+    "OneToOne": "one_to_one",
+    "ManyToMany": "many_to_many",
+}
+_RELATIONSHIP_RE = re.compile(r"@(OneToMany|ManyToOne|OneToOne|ManyToMany)")
+_TARGET_ENTITY_RE = re.compile(r'targetEntity\s*=\s*(\w+)\.class')
+_MAPPED_BY_RE = re.compile(r'mappedBy\s*=\s*"(\w+)"')
+_GENERIC_TYPE_RE = re.compile(r'<(\w+)>')
+
+
+class JpaEntityDetector:
+    """Detects JPA entities and their relationships."""
+
+    name: str = "jpa_entity"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        # Check if file contains @Entity
+        if not _ENTITY_RE.search(text):
+            return result
+
+        # Find class name
+        class_name: str | None = None
+        class_line: int = 0
+        for i, line in enumerate(lines):
+            cm = _CLASS_RE.search(line)
+            if cm:
+                class_name = cm.group(1)
+                class_line = i + 1
+                break
+
+        if not class_name:
+            return result
+
+        # Extract table name
+        table_match = _TABLE_RE.search(text)
+        table_name = table_match.group(1) if table_match else class_name.lower()
+
+        # Extract columns
+        columns: list[dict[str, str]] = []
+        for i, line in enumerate(lines):
+            col_match = _COLUMN_RE.search(line)
+            if col_match:
+                col_name_match = _COLUMN_NAME_RE.search(col_match.group(1))
+                # Find the field on the next line(s)
+                for k in range(i + 1, min(i + 3, len(lines))):
+                    fm = _FIELD_RE.search(lines[k])
+                    if fm:
+                        col_name = col_name_match.group(1) if col_name_match else fm.group(2)
+                        columns.append({"name": col_name, "field": fm.group(2), "type": fm.group(1).strip()})
+                        break
+
+        entity_id = f"{ctx.file_path}:{class_name}"
+        properties: dict[str, Any] = {"table_name": table_name}
+        if columns:
+            properties["columns"] = columns
+
+        node = GraphNode(
+            id=entity_id,
+            kind=NodeKind.ENTITY,
+            label=f"{class_name} ({table_name})",
+            fqn=class_name,
+            module=ctx.module_name,
+            location=SourceLocation(file_path=ctx.file_path, line_start=class_line),
+            annotations=["@Entity"],
+            properties=properties,
+        )
+        result.nodes.append(node)
+
+        # Extract relationships
+        for i, line in enumerate(lines):
+            rel_match = _RELATIONSHIP_RE.search(line)
+            if not rel_match:
+                continue
+
+            rel_type = _RELATIONSHIP_ANNOTATIONS[rel_match.group(1)]
+
+            # Determine target entity
+            target_entity: str | None = None
+            # Check for targetEntity attribute
+            target_match = _TARGET_ENTITY_RE.search(line)
+            if target_match:
+                target_entity = target_match.group(1)
+            else:
+                # Look at field type on subsequent lines
+                for k in range(i + 1, min(i + 4, len(lines))):
+                    fm = _FIELD_RE.search(lines[k])
+                    if fm:
+                        field_type = fm.group(1).strip()
+                        gm = _GENERIC_TYPE_RE.search(field_type)
+                        if gm:
+                            target_entity = gm.group(1)
+                        else:
+                            # Direct type reference (e.g., ManyToOne Address)
+                            target_entity = field_type.split()[-1] if field_type else None
+                        break
+
+            if target_entity:
+                mapped_by = _MAPPED_BY_RE.search(line)
+                edge_props: dict[str, Any] = {"relationship_type": rel_type}
+                if mapped_by:
+                    edge_props["mapped_by"] = mapped_by.group(1)
+
+                edge = GraphEdge(
+                    source=entity_id,
+                    target=f"*:{target_entity}",  # Wildcard target resolved later
+                    kind=EdgeKind.MAPS_TO,
+                    label=f"{class_name} {rel_type} {target_entity}",
+                    properties=edge_props,
+                )
+                result.edges.append(edge)
+
+        return result