osscodeiq 0.0.0__py3-none-any.whl

osscodeiq/detectors/java/config_def.py

@@ -0,0 +1,82 @@
+"""ConfigDef detector for Java source files using Kafka's ConfigDef.define() pattern."""
+
+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+)")
+_DEFINE_RE = re.compile(r'\.define\s*\(\s*"([^"]+)"')
+
+
+class ConfigDefDetector:
+    """Detects Kafka ConfigDef.define() configuration definitions."""
+
+    name: str = "config_def"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        if "ConfigDef" 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_keys: set[str] = set()
+
+        # Find all .define("config.key") calls
+        for i, line in enumerate(lines):
+            m = _DEFINE_RE.search(line)
+            if not m:
+                continue
+
+            config_key = m.group(1)
+            if config_key in seen_keys:
+                continue
+            seen_keys.add(config_key)
+
+            node_id = f"config:{config_key}"
+
+            result.nodes.append(GraphNode(
+                id=node_id,
+                kind=NodeKind.CONFIG_DEFINITION,
+                label=config_key,
+                location=SourceLocation(
+                    file_path=ctx.file_path,
+                    line_start=i + 1,
+                ),
+                properties={"config_key": config_key},
+            ))
+
+            result.edges.append(GraphEdge(
+                source=class_node_id,
+                target=node_id,
+                kind=EdgeKind.READS_CONFIG,
+                label=f"{class_name} reads config {config_key}",
+                properties={"config_key": config_key},
+            ))
+
+        return result

osscodeiq/detectors/java/cosmos_db.py

@@ -0,0 +1,105 @@
+"""Azure Cosmos DB client usage detector for Java and TypeScript/JavaScript."""
+
+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+)")
+_DATABASE_RE = re.compile(r'\.(?:getDatabase|database)\s*\(\s*"([^"]+)"')
+_CONTAINER_RE = re.compile(r'\.(?:getContainer|container)\s*\(\s*"([^"]+)"')
+
+
+class CosmosDbDetector:
+    """Detects Azure Cosmos DB client usage patterns."""
+
+    name: str = "cosmos_db"
+    supported_languages: tuple[str, ...] = ("java", "typescript", "javascript")
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+
+        # Fast bail
+        if (
+            "CosmosClient" not in text
+            and "CosmosDatabase" not in text
+            and "CosmosContainer" not in text
+            and "@azure/cosmos" not in text
+        ):
+            return result
+
+        lines = text.split("\n")
+
+        # Find class name (for Java) or use file path as source
+        class_name: str | None = None
+        for line in lines:
+            cm = _CLASS_RE.search(line)
+            if cm:
+                class_name = cm.group(1)
+                break
+
+        source_node_id = f"{ctx.file_path}:{class_name}" if class_name else ctx.file_path
+        seen_databases: set[str] = set()
+        seen_containers: set[str] = set()
+
+        for i, line in enumerate(lines):
+            # Detect database references
+            for db_match in _DATABASE_RE.finditer(line):
+                db_name = db_match.group(1)
+                if db_name not in seen_databases:
+                    seen_databases.add(db_name)
+                    db_node_id = f"azure:cosmos:db:{db_name}"
+                    result.nodes.append(GraphNode(
+                        id=db_node_id,
+                        kind=NodeKind.AZURE_RESOURCE,
+                        label=f"cosmosdb:{db_name}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=i + 1),
+                        properties={
+                            "cosmos_type": "database",
+                            "resource_name": db_name,
+                        },
+                    ))
+                    result.edges.append(GraphEdge(
+                        source=source_node_id,
+                        target=db_node_id,
+                        kind=EdgeKind.CONNECTS_TO,
+                        label=f"{class_name or ctx.file_path} connects to cosmosdb:{db_name}",
+                    ))
+
+            # Detect container references
+            for cont_match in _CONTAINER_RE.finditer(line):
+                container_name = cont_match.group(1)
+                if container_name not in seen_containers:
+                    seen_containers.add(container_name)
+                    container_node_id = f"azure:cosmos:container:{container_name}"
+                    result.nodes.append(GraphNode(
+                        id=container_node_id,
+                        kind=NodeKind.AZURE_RESOURCE,
+                        label=f"cosmosdb-container:{container_name}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=i + 1),
+                        properties={
+                            "cosmos_type": "container",
+                            "resource_name": container_name,
+                        },
+                    ))
+                    result.edges.append(GraphEdge(
+                        source=source_node_id,
+                        target=container_node_id,
+                        kind=EdgeKind.CONNECTS_TO,
+                        label=f"{class_name or ctx.file_path} connects to container:{container_name}",
+                    ))
+
+        return result

osscodeiq/detectors/java/graphql_resolver.py

@@ -0,0 +1,188 @@
+"""GraphQL resolver 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+)")
+
+# Spring GraphQL annotations
+_QUERY_MAPPING_RE = re.compile(r"@QueryMapping(?:\s*\(\s*(?:name\s*=\s*)?\"([^\"]+)\"\s*\))?")
+_MUTATION_MAPPING_RE = re.compile(r"@MutationMapping(?:\s*\(\s*(?:name\s*=\s*)?\"([^\"]+)\"\s*\))?")
+_SUBSCRIPTION_MAPPING_RE = re.compile(r"@SubscriptionMapping(?:\s*\(\s*(?:name\s*=\s*)?\"([^\"]+)\"\s*\))?")
+_SCHEMA_MAPPING_RE = re.compile(r'@SchemaMapping\s*\(\s*(?:typeName\s*=\s*"([^"]+)")?')
+_BATCH_MAPPING_RE = re.compile(r"@BatchMapping(?:\s*\(\s*(?:field\s*=\s*)?\"([^\"]+)\"\s*\))?")
+
+# DGS framework annotations
+_DGS_QUERY_RE = re.compile(r"@DgsQuery(?:\s*\(\s*field\s*=\s*\"([^\"]+)\"\s*\))?")
+_DGS_MUTATION_RE = re.compile(r"@DgsMutation(?:\s*\(\s*field\s*=\s*\"([^\"]+)\"\s*\))?")
+_DGS_SUBSCRIPTION_RE = re.compile(r"@DgsSubscription(?:\s*\(\s*field\s*=\s*\"([^\"]+)\"\s*\))?")
+_DGS_DATA_RE = re.compile(r"@DgsData\s*\(\s*parentType\s*=\s*\"([^\"]+)\"(?:\s*,\s*field\s*=\s*\"([^\"]+)\")?")
+
+_METHOD_RE = re.compile(r"(?:public|protected|private)?\s*(?:[\w<>\[\],?\s]+)\s+(\w+)\s*\(")
+
+# Controller annotation for GraphQL controllers
+_CONTROLLER_RE = re.compile(r"@(?:Controller|DgsComponent)")
+
+
+class GraphqlResolverDetector:
+    """Detects GraphQL resolvers from Spring GraphQL and DGS framework annotations."""
+
+    name: str = "graphql_resolver"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        # Quick check for relevant annotations
+        if not any(kw in text for kw in (
+            "@QueryMapping", "@MutationMapping", "@SubscriptionMapping",
+            "@SchemaMapping", "@BatchMapping",
+            "@DgsQuery", "@DgsMutation", "@DgsSubscription", "@DgsData",
+        )):
+            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}"
+
+        # All annotation patterns to scan
+        patterns = [
+            (_QUERY_MAPPING_RE, "Query"),
+            (_MUTATION_MAPPING_RE, "Mutation"),
+            (_SUBSCRIPTION_MAPPING_RE, "Subscription"),
+            (_DGS_QUERY_RE, "Query"),
+            (_DGS_MUTATION_RE, "Mutation"),
+            (_DGS_SUBSCRIPTION_RE, "Subscription"),
+        ]
+
+        for i, line in enumerate(lines):
+            for pattern, gql_type in patterns:
+                m = pattern.search(line)
+                if not m:
+                    continue
+
+                field_name = m.group(1) if m.lastindex and m.group(1) else None
+                # Resolve field name from method if not in annotation
+                if not field_name:
+                    for k in range(i + 1, min(i + 4, len(lines))):
+                        mm = _METHOD_RE.search(lines[k])
+                        if mm:
+                            field_name = mm.group(1)
+                            break
+
+                if not field_name:
+                    continue
+
+                resolver_id = f"{ctx.file_path}:{class_name}:{gql_type}:{field_name}"
+                result.nodes.append(GraphNode(
+                    id=resolver_id,
+                    kind=NodeKind.ENDPOINT,
+                    label=f"GraphQL {gql_type}.{field_name}",
+                    fqn=f"{class_name}.{field_name}",
+                    module=ctx.module_name,
+                    location=SourceLocation(file_path=ctx.file_path, line_start=i + 1),
+                    properties={
+                        "graphql_type": gql_type,
+                        "field": field_name,
+                        "protocol": "graphql",
+                    },
+                ))
+
+                result.edges.append(GraphEdge(
+                    source=class_node_id,
+                    target=resolver_id,
+                    kind=EdgeKind.EXPOSES,
+                    label=f"{class_name} exposes {gql_type}.{field_name}",
+                ))
+
+            # Handle @SchemaMapping
+            sm = _SCHEMA_MAPPING_RE.search(line)
+            if sm:
+                type_name = sm.group(1) or "Unknown"
+                method_name = None
+                for k in range(i + 1, min(i + 4, len(lines))):
+                    mm = _METHOD_RE.search(lines[k])
+                    if mm:
+                        method_name = mm.group(1)
+                        break
+
+                if method_name:
+                    resolver_id = f"{ctx.file_path}:{class_name}:SchemaMapping:{type_name}.{method_name}"
+                    result.nodes.append(GraphNode(
+                        id=resolver_id,
+                        kind=NodeKind.ENDPOINT,
+                        label=f"GraphQL {type_name}.{method_name}",
+                        fqn=f"{class_name}.{method_name}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=i + 1),
+                        properties={
+                            "graphql_type": type_name,
+                            "field": method_name,
+                            "protocol": "graphql",
+                        },
+                    ))
+                    result.edges.append(GraphEdge(
+                        source=class_node_id,
+                        target=resolver_id,
+                        kind=EdgeKind.EXPOSES,
+                        label=f"{class_name} exposes {type_name}.{method_name}",
+                    ))
+
+            # Handle @DgsData
+            dm = _DGS_DATA_RE.search(line)
+            if dm:
+                parent_type = dm.group(1)
+                field_name = dm.group(2) if dm.lastindex and dm.lastindex >= 2 and dm.group(2) else None
+                if not field_name:
+                    for k in range(i + 1, min(i + 4, len(lines))):
+                        mm = _METHOD_RE.search(lines[k])
+                        if mm:
+                            field_name = mm.group(1)
+                            break
+
+                if field_name:
+                    resolver_id = f"{ctx.file_path}:{class_name}:DgsData:{parent_type}.{field_name}"
+                    result.nodes.append(GraphNode(
+                        id=resolver_id,
+                        kind=NodeKind.ENDPOINT,
+                        label=f"GraphQL {parent_type}.{field_name}",
+                        fqn=f"{class_name}.{field_name}",
+                        module=ctx.module_name,
+                        location=SourceLocation(file_path=ctx.file_path, line_start=i + 1),
+                        properties={
+                            "graphql_type": parent_type,
+                            "field": field_name,
+                            "protocol": "graphql",
+                            "framework": "dgs",
+                        },
+                    ))
+                    result.edges.append(GraphEdge(
+                        source=class_node_id,
+                        target=resolver_id,
+                        kind=EdgeKind.EXPOSES,
+                        label=f"{class_name} exposes {parent_type}.{field_name}",
+                    ))
+
+        return result

osscodeiq/detectors/java/grpc_service.py

@@ -0,0 +1,142 @@
+"""gRPC 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+)")
+
+# gRPC service implementation pattern: extends XxxGrpc.XxxImplBase
+_GRPC_IMPL_RE = re.compile(
+    r"class\s+(\w+)\s+extends\s+(\w+)Grpc\.(\w+)ImplBase"
+)
+
+# @GrpcService annotation (grpc-spring-boot-starter)
+_GRPC_SERVICE_ANNO_RE = re.compile(r"@GrpcService")
+
+# Override methods in gRPC service
+_OVERRIDE_METHOD_RE = re.compile(
+    r"@Override\s+\n?\s*public\s+void\s+(\w+)\s*\("
+)
+
+# gRPC channel/stub usage for client detection
+_GRPC_STUB_RE = re.compile(
+    r"(\w+)Grpc\.new(?:Blocking|Future|)Stub\s*\("
+)
+_GRPC_CHANNEL_RE = re.compile(
+    r'ManagedChannelBuilder\s*\.forAddress\s*\(\s*"([^"]+)"\s*,\s*(\d+)'
+)
+
+# Method override pattern (simpler)
+_METHOD_RE = re.compile(
+    r"(?:public)\s+(?:void|[\w<>\[\]]+)\s+(\w+)\s*\(\s*(\w+)"
+)
+
+
+class GrpcServiceDetector:
+    """Detects gRPC service implementations and client stubs."""
+
+    name: str = "grpc_service"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        has_grpc_impl = "ImplBase" in text or "@GrpcService" in text
+        has_grpc_stub = "Grpc.new" in text
+
+        if not has_grpc_impl and not has_grpc_stub:
+            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
+
+        class_node_id = f"{ctx.file_path}:{class_name}"
+
+        # Detect gRPC service implementation
+        impl_match = _GRPC_IMPL_RE.search(text)
+        if impl_match:
+            service_proto = impl_match.group(2)  # The proto service name
+            service_id = f"grpc:service:{service_proto}"
+
+            result.nodes.append(GraphNode(
+                id=service_id,
+                kind=NodeKind.ENDPOINT,
+                label=f"gRPC {service_proto}",
+                fqn=f"{class_name} ({service_proto})",
+                module=ctx.module_name,
+                location=SourceLocation(file_path=ctx.file_path, line_start=class_line),
+                annotations=["@GrpcService"] if "@GrpcService" in text else [],
+                properties={
+                    "protocol": "grpc",
+                    "service": service_proto,
+                    "implementation": class_name,
+                },
+            ))
+
+            result.edges.append(GraphEdge(
+                source=class_node_id,
+                target=service_id,
+                kind=EdgeKind.EXPOSES,
+                label=f"{class_name} implements gRPC {service_proto}",
+            ))
+
+            # Find RPC methods (overridden methods)
+            for i, line in enumerate(lines):
+                if "@Override" in line:
+                    for k in range(i + 1, min(i + 3, len(lines))):
+                        mm = _METHOD_RE.search(lines[k])
+                        if mm:
+                            method_name = mm.group(1)
+                            rpc_id = f"grpc:rpc:{service_proto}/{method_name}"
+                            result.nodes.append(GraphNode(
+                                id=rpc_id,
+                                kind=NodeKind.ENDPOINT,
+                                label=f"gRPC {service_proto}/{method_name}",
+                                fqn=f"{class_name}.{method_name}",
+                                module=ctx.module_name,
+                                location=SourceLocation(file_path=ctx.file_path, line_start=k + 1),
+                                properties={
+                                    "protocol": "grpc",
+                                    "service": service_proto,
+                                    "method": method_name,
+                                },
+                            ))
+                            break
+
+        # Detect gRPC client stubs
+        for m in _GRPC_STUB_RE.finditer(text):
+            target_service = m.group(1)
+            line_num = text[:m.start()].count("\n") + 1
+
+            result.edges.append(GraphEdge(
+                source=class_node_id,
+                target=f"grpc:service:{target_service}",
+                kind=EdgeKind.CALLS,
+                label=f"{class_name} calls gRPC {target_service}",
+                properties={"protocol": "grpc", "target_service": target_service},
+            ))
+
+        return result

osscodeiq/detectors/java/ibm_mq.py

@@ -0,0 +1,178 @@
+"""IBM MQ 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+)")
+
+# MQQueueManager instantiation with name
+_QM_NEW_RE = re.compile(r'new\s+MQQueueManager\s*\(\s*"([^"]+)"')
+
+# accessQueue("QUEUE_NAME", ...)
+_ACCESS_QUEUE_RE = re.compile(r'accessQueue\s*\(\s*"([^"]+)"')
+
+# MQQueue / MQTopic field or local variable declarations
+_MQ_QUEUE_DECL_RE = re.compile(r'\bMQQueue\b')
+_MQ_TOPIC_DECL_RE = re.compile(r'\bMQTopic\b')
+
+# JMS-style IBM MQ connection factory
+_MQ_JMS_FACTORY_RE = re.compile(r'\bMQConnectionFactory\b|\bMQQueueConnectionFactory\b|\bMQTopicConnectionFactory\b')
+
+# createQueue / createTopic with IBM MQ JMS
+_JMS_CREATE_QUEUE_RE = re.compile(r'createQueue\s*\(\s*"([^"]+)"')
+_JMS_CREATE_TOPIC_RE = re.compile(r'createTopic\s*\(\s*"([^"]+)"')
+
+# put / get calls indicate send / receive
+_MQ_PUT_RE = re.compile(r'\bput\s*\(')
+_MQ_GET_RE = re.compile(r'\bget\s*\(')
+
+
+class IbmMqDetector:
+    """Detects IBM MQ queue manager, queue, and topic usage in Java source files."""
+
+    name: str = "ibm_mq"
+    supported_languages: tuple[str, ...] = ("java",)
+
+    def detect(self, ctx: DetectorContext) -> DetectorResult:
+        result = DetectorResult()
+        text = decode_text(ctx)
+        lines = text.split("\n")
+
+        if "MQQueueManager" not in text and "JmsConnectionFactory" not in text and "com.ibm.mq" not in text and "MQQueue" 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_qms: set[str] = set()
+        seen_queues: set[str] = set()
+        seen_topics: set[str] = set()
+
+        def _ensure_qm_node(qm_name: str) -> str:
+            qm_id = f"ibmmq:qm:{qm_name}"
+            if qm_name not in seen_qms:
+                seen_qms.add(qm_name)
+                result.nodes.append(GraphNode(
+                    id=qm_id,
+                    kind=NodeKind.MESSAGE_QUEUE,
+                    label=f"ibmmq:qm:{qm_name}",
+                    properties={"broker": "ibm_mq", "queue_manager": qm_name},
+                ))
+            return qm_id
+
+        def _ensure_queue_node(queue_name: str) -> str:
+            queue_id = f"ibmmq:queue:{queue_name}"
+            if queue_name not in seen_queues:
+                seen_queues.add(queue_name)
+                result.nodes.append(GraphNode(
+                    id=queue_id,
+                    kind=NodeKind.QUEUE,
+                    label=f"ibmmq:queue:{queue_name}",
+                    properties={"broker": "ibm_mq", "queue": queue_name},
+                ))
+            return queue_id
+
+        def _ensure_topic_node(topic_name: str) -> str:
+            topic_id = f"ibmmq:topic:{topic_name}"
+            if topic_name not in seen_topics:
+                seen_topics.add(topic_name)
+                result.nodes.append(GraphNode(
+                    id=topic_id,
+                    kind=NodeKind.TOPIC,
+                    label=f"ibmmq:topic:{topic_name}",
+                    properties={"broker": "ibm_mq", "topic": topic_name},
+                ))
+            return topic_id
+
+        # Track whether we see put/get patterns for edge direction
+        has_put = bool(_MQ_PUT_RE.search(text))
+        has_get = bool(_MQ_GET_RE.search(text))
+
+        # Detect MQQueueManager instantiation
+        for i, line in enumerate(lines):
+            m = _QM_NEW_RE.search(line)
+            if m:
+                qm_name = m.group(1)
+                qm_id = _ensure_qm_node(qm_name)
+                result.edges.append(GraphEdge(
+                    source=class_node_id,
+                    target=qm_id,
+                    kind=EdgeKind.CONNECTS_TO,
+                    label=f"{class_name} connects to queue manager {qm_name}",
+                    properties={"queue_manager": qm_name},
+                ))
+
+        # Detect accessQueue calls
+        for i, line in enumerate(lines):
+            m = _ACCESS_QUEUE_RE.search(line)
+            if m:
+                queue_name = m.group(1)
+                queue_id = _ensure_queue_node(queue_name)
+                if has_put:
+                    result.edges.append(GraphEdge(
+                        source=class_node_id,
+                        target=queue_id,
+                        kind=EdgeKind.SENDS_TO,
+                        label=f"{class_name} sends to {queue_name}",
+                        properties={"queue": queue_name},
+                    ))
+                if has_get:
+                    result.edges.append(GraphEdge(
+                        source=class_node_id,
+                        target=queue_id,
+                        kind=EdgeKind.RECEIVES_FROM,
+                        label=f"{class_name} receives from {queue_name}",
+                        properties={"queue": queue_name},
+                    ))
+                if not has_put and not has_get:
+                    result.edges.append(GraphEdge(
+                        source=class_node_id,
+                        target=queue_id,
+                        kind=EdgeKind.CONNECTS_TO,
+                        label=f"{class_name} accesses {queue_name}",
+                        properties={"queue": queue_name},
+                    ))
+
+        # Detect JMS-style createQueue / createTopic
+        for i, line in enumerate(lines):
+            m = _JMS_CREATE_QUEUE_RE.search(line)
+            if m:
+                queue_name = m.group(1)
+                _ensure_queue_node(queue_name)
+
+            m = _JMS_CREATE_TOPIC_RE.search(line)
+            if m:
+                topic_name = m.group(1)
+                _ensure_topic_node(topic_name)
+
+        # If we found MQTopic declarations but no explicit topic names, create a
+        # generic node to show MQ topic usage
+        if _MQ_TOPIC_DECL_RE.search(text) and not seen_topics:
+            result.nodes.append(GraphNode(
+                id=f"ibmmq:topic:__unknown__",
+                kind=NodeKind.TOPIC,
+                label="ibmmq:topic:unknown",
+                properties={"broker": "ibm_mq"},
+            ))
+
+        return result