api-tests-coverage 1.0.21 → 1.0.22

package/dist/src/reporting.js

@@ -269,7 +269,8 @@ function checkThresholds(results, thresholds) {
     const failures = [];
     for (const result of results) {
         const threshold = thresholds[result.type];
-        if (threshold !== undefined && result.coveragePercent < threshold) {
+        // Skip threshold check when there are no items to measure (N/A status)
+        if (threshold !== undefined && result.totalItems > 0 && result.coveragePercent < threshold) {
             const gap = (threshold - result.coveragePercent).toFixed(2);
             failures.push(`${result.type} coverage ${result.coveragePercent}% is below threshold ${threshold}% (gap: ${gap}%)`);
         }

package/dist/src/streaming/detectors/eventBridgeDetector.d.ts

@@ -0,0 +1,5 @@
+import type { EventNode } from '../types';
+export declare class EventBridgeDetector {
+    detect(fileContent: string, filePath: string): EventNode[];
+}
+//# sourceMappingURL=eventBridgeDetector.d.ts.map

package/dist/src/streaming/detectors/eventBridgeDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventBridgeDetector.d.ts","sourceRoot":"","sources":["../../../../src/streaming/detectors/eventBridgeDetector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAmB,MAAM,UAAU,CAAC;AAsB3D,qBAAa,mBAAmB;IAC9B,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE;CA2D3D"}

package/dist/src/streaming/detectors/eventBridgeDetector.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBridgeDetector = void 0;
+function resolveTopicString(raw) {
+    var _a;
+    const trimmed = raw.trim();
+    const envMatch = (_a = trimmed.match(/process\.env\.([A-Z_a-z][A-Z_a-z0-9]*)/)) !== null && _a !== void 0 ? _a : trimmed.match(/process\.env\[['"]([A-Z_a-z][A-Z_a-z0-9]*)['"]\]/);
+    if (envMatch) {
+        return { topic: `UNRESOLVED:env:${envMatch[1]}`, resolution: `UNRESOLVED:env:${envMatch[1]}` };
+    }
+    if (trimmed.includes('${')) {
+        return { topic: 'UNRESOLVED:dynamic', resolution: 'UNRESOLVED:dynamic' };
+    }
+    const literalMatch = trimmed.match(/^['"`]([^'"`]+)['"`]$/);
+    if (literalMatch) {
+        return { topic: literalMatch[1], resolution: 'resolved' };
+    }
+    if (trimmed.match(/^[A-Za-z_][A-Za-z_0-9.]*$/)) {
+        return { topic: trimmed, resolution: 'cross-file-unresolved' };
+    }
+    return { topic: 'UNRESOLVED:dynamic', resolution: 'UNRESOLVED:dynamic' };
+}
+class EventBridgeDetector {
+    detect(fileContent, filePath) {
+        const nodes = [];
+        try {
+            let idx = 0;
+            let match;
+            // eventBridge.putEvents({ Entries: [{ EventBusName: '...' }] })
+            // PutEventsCommand({ Entries: [{...}] }) — look for EventBusName
+            const putEventsRegex = /(?:putEvents|PutEventsCommand)\s*\(\s*\{[^}]*EventBusName\s*:\s*([^,}\n]+)/g;
+            while ((match = putEventsRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `eventbridge-producer-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'eventbridge',
+                    nodeType: 'producer',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+            // Also detect Source field in putEvents entries
+            const sourceRegex = /(?:putEvents|PutEventsCommand)[^;]*?Source\s*:\s*([^,}\n]+)/g;
+            while ((match = sourceRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `eventbridge-source-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'eventbridge',
+                    nodeType: 'producer',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+            // @EventBridgeHandler annotation (AWS Lambda handler)
+            const handlerRegex = /@EventBridgeHandler\s*\([^)]*source\s*=\s*([^,)]+)/g;
+            while ((match = handlerRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `eventbridge-handler-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'eventbridge',
+                    nodeType: 'consumer',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+        }
+        catch {
+            // never throws
+        }
+        return nodes;
+    }
+}
+exports.EventBridgeDetector = EventBridgeDetector;

package/dist/src/streaming/detectors/kafkaDetector.d.ts

@@ -0,0 +1,5 @@
+import type { EventNode } from '../types';
+export declare class KafkaDetector {
+    detect(fileContent: string, filePath: string): EventNode[];
+}
+//# sourceMappingURL=kafkaDetector.d.ts.map

package/dist/src/streaming/detectors/kafkaDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafkaDetector.d.ts","sourceRoot":"","sources":["../../../../src/streaming/detectors/kafkaDetector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAmB,MAAM,UAAU,CAAC;AAuB3D,qBAAa,aAAa;IACxB,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE;CAwE3D"}

package/dist/src/streaming/detectors/kafkaDetector.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaDetector = void 0;
+function resolveTopicString(raw) {
+    var _a;
+    const trimmed = raw.trim();
+    // env var reference: process.env.TOPIC_NAME or process.env['TOPIC_NAME']
+    const envMatch = (_a = trimmed.match(/process\.env\.([A-Z_a-z][A-Z_a-z0-9]*)/)) !== null && _a !== void 0 ? _a : trimmed.match(/process\.env\[['"]([A-Z_a-z][A-Z_a-z0-9]*)['"]\]/);
+    if (envMatch) {
+        return { topic: `UNRESOLVED:env:${envMatch[1]}`, resolution: `UNRESOLVED:env:${envMatch[1]}` };
+    }
+    // Template literal or other dynamic: contains ${
+    if (trimmed.includes('${')) {
+        return { topic: 'UNRESOLVED:dynamic', resolution: 'UNRESOLVED:dynamic' };
+    }
+    // Quoted string literal — the topic is known at compile time
+    const literalMatch = trimmed.match(/^['"`]([^'"`]+)['"`]$/);
+    if (literalMatch) {
+        return { topic: literalMatch[1], resolution: 'resolved' };
+    }
+    // Bare identifier (variable, constant reference) — topic value unknown without cross-file analysis
+    return { topic: `UNRESOLVED:dynamic`, resolution: 'cross-file-unresolved' };
+}
+class KafkaDetector {
+    detect(fileContent, filePath) {
+        var _a, _b, _c, _d;
+        const nodes = [];
+        try {
+            // new Kafka({...}) — just marks file as kafka-aware, not a node itself
+            // producer.send({topic: '...'}) or send({topic: '...'})
+            const producerSendRegex = /(?:producer\.send|\.send)\s*\(\s*\{[^}]*topic\s*:\s*([^,}\n]+)/g;
+            let match;
+            let idx = 0;
+            while ((match = producerSendRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `kafka-producer-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'kafka',
+                    nodeType: 'producer',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+            // consumer.subscribe({topics: ['...']}) or subscribe({topic: '...'})
+            const subscribeRegex = /(?:consumer\.subscribe|\.subscribe)\s*\(\s*\{[^}]*topics?\s*:\s*(?:\[([^\]]*)\]|([^,}\n]+))/g;
+            while ((match = subscribeRegex.exec(fileContent)) !== null) {
+                const raw = (_b = (_a = match[1]) !== null && _a !== void 0 ? _a : match[2]) !== null && _b !== void 0 ? _b : '';
+                // might be array of topics
+                const topicItems = match[1]
+                    ? match[1].split(',').map((t) => t.trim()).filter(Boolean)
+                    : [raw.trim()];
+                for (const topicRaw of topicItems) {
+                    const { topic, resolution } = resolveTopicString(topicRaw);
+                    nodes.push({
+                        id: `kafka-consumer-${filePath}-${idx++}`,
+                        filePath,
+                        brokerType: 'kafka',
+                        nodeType: 'consumer',
+                        topic,
+                        resolution,
+                        hasTest: false,
+                        testFiles: [],
+                    });
+                }
+            }
+            // @KafkaListener(topics = "topicName") or @KafkaListener(topics = {"t1","t2"})
+            const kafkaListenerRegex = /@KafkaListener\s*\([^)]*topics\s*=\s*(?:\{([^}]*)\}|([^,)"\s]+|"[^"]*"))/g;
+            while ((match = kafkaListenerRegex.exec(fileContent)) !== null) {
+                const rawTopics = (_d = (_c = match[1]) !== null && _c !== void 0 ? _c : match[2]) !== null && _d !== void 0 ? _d : '';
+                const topicItems = match[1]
+                    ? rawTopics.split(',').map((t) => t.trim()).filter(Boolean)
+                    : [rawTopics.trim()];
+                for (const topicRaw of topicItems) {
+                    const { topic, resolution } = resolveTopicString(topicRaw);
+                    nodes.push({
+                        id: `kafka-listener-${filePath}-${idx++}`,
+                        filePath,
+                        brokerType: 'kafka',
+                        nodeType: 'consumer',
+                        topic,
+                        resolution,
+                        hasTest: false,
+                        testFiles: [],
+                    });
+                }
+            }
+        }
+        catch {
+            // never throws
+        }
+        return nodes;
+    }
+}
+exports.KafkaDetector = KafkaDetector;

package/dist/src/streaming/detectors/natsDetector.d.ts

@@ -0,0 +1,5 @@
+import type { EventNode } from '../types';
+export declare class NatsDetector {
+    detect(fileContent: string, filePath: string): EventNode[];
+}
+//# sourceMappingURL=natsDetector.d.ts.map

package/dist/src/streaming/detectors/natsDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"natsDetector.d.ts","sourceRoot":"","sources":["../../../../src/streaming/detectors/natsDetector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAmB,MAAM,UAAU,CAAC;AAsB3D,qBAAa,YAAY;IACvB,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE;CA0E3D"}

package/dist/src/streaming/detectors/natsDetector.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsDetector = void 0;
+function resolveTopicString(raw) {
+    var _a;
+    const trimmed = raw.trim();
+    const envMatch = (_a = trimmed.match(/process\.env\.([A-Z_a-z][A-Z_a-z0-9]*)/)) !== null && _a !== void 0 ? _a : trimmed.match(/process\.env\[['"]([A-Z_a-z][A-Z_a-z0-9]*)['"]\]/);
+    if (envMatch) {
+        return { topic: `UNRESOLVED:env:${envMatch[1]}`, resolution: `UNRESOLVED:env:${envMatch[1]}` };
+    }
+    if (trimmed.includes('${')) {
+        return { topic: 'UNRESOLVED:dynamic', resolution: 'UNRESOLVED:dynamic' };
+    }
+    const literalMatch = trimmed.match(/^['"`]([^'"`]+)['"`]$/);
+    if (literalMatch) {
+        return { topic: literalMatch[1], resolution: 'resolved' };
+    }
+    if (trimmed.match(/^[A-Za-z_][A-Za-z_0-9.]*$/)) {
+        return { topic: trimmed, resolution: 'cross-file-unresolved' };
+    }
+    return { topic: 'UNRESOLVED:dynamic', resolution: 'UNRESOLVED:dynamic' };
+}
+class NatsDetector {
+    detect(fileContent, filePath) {
+        const nodes = [];
+        try {
+            let idx = 0;
+            let match;
+            // nc.publish('subject', ...) or js.publish('subject', ...)
+            const publishRegex = /(?:nc|js|nats)\.publish\s*\(\s*([^,)]+)/g;
+            while ((match = publishRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `nats-producer-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'nats',
+                    nodeType: 'producer',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+            // nc.subscribe('subject', ...) or js.subscribe('subject', ...)
+            const subscribeRegex = /(?:nc|js|nats)\.subscribe\s*\(\s*([^,)]+)/g;
+            while ((match = subscribeRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `nats-consumer-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'nats',
+                    nodeType: 'consumer',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+            // @Subscription('subject') annotation (NestJS NATS microservice)
+            const subscriptionAnnotationRegex = /@Subscription\s*\(\s*([^)]+)\)/g;
+            while ((match = subscriptionAnnotationRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `nats-subscription-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'nats',
+                    nodeType: 'consumer',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+            // @MessagePattern annotation often used with NATS in NestJS
+            const messagePatternRegex = /@MessagePattern\s*\(\s*([^)]+)\)/g;
+            while ((match = messagePatternRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `nats-pattern-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'nats',
+                    nodeType: 'consumer',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+        }
+        catch {
+            // never throws
+        }
+        return nodes;
+    }
+}
+exports.NatsDetector = NatsDetector;

package/dist/src/streaming/detectors/pubsubDetector.d.ts

@@ -0,0 +1,5 @@
+import type { EventNode } from '../types';
+export declare class PubsubDetector {
+    detect(fileContent: string, filePath: string): EventNode[];
+}
+//# sourceMappingURL=pubsubDetector.d.ts.map

package/dist/src/streaming/detectors/pubsubDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pubsubDetector.d.ts","sourceRoot":"","sources":["../../../../src/streaming/detectors/pubsubDetector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAmB,MAAM,UAAU,CAAC;AAsB3D,qBAAa,cAAc;IACzB,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE;CA2D3D"}

package/dist/src/streaming/detectors/pubsubDetector.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PubsubDetector = void 0;
+function resolveTopicString(raw) {
+    var _a;
+    const trimmed = raw.trim();
+    const envMatch = (_a = trimmed.match(/process\.env\.([A-Z_a-z][A-Z_a-z0-9]*)/)) !== null && _a !== void 0 ? _a : trimmed.match(/process\.env\[['"]([A-Z_a-z][A-Z_a-z0-9]*)['"]\]/);
+    if (envMatch) {
+        return { topic: `UNRESOLVED:env:${envMatch[1]}`, resolution: `UNRESOLVED:env:${envMatch[1]}` };
+    }
+    if (trimmed.includes('${')) {
+        return { topic: 'UNRESOLVED:dynamic', resolution: 'UNRESOLVED:dynamic' };
+    }
+    const literalMatch = trimmed.match(/^['"`]([^'"`]+)['"`]$/);
+    if (literalMatch) {
+        return { topic: literalMatch[1], resolution: 'resolved' };
+    }
+    if (trimmed.match(/^[A-Za-z_][A-Za-z_0-9.]*$/)) {
+        return { topic: trimmed, resolution: 'cross-file-unresolved' };
+    }
+    return { topic: 'UNRESOLVED:dynamic', resolution: 'UNRESOLVED:dynamic' };
+}
+class PubsubDetector {
+    detect(fileContent, filePath) {
+        const nodes = [];
+        try {
+            let idx = 0;
+            let match;
+            // pubsub.topic('topicName').publish(...)
+            const topicPublishRegex = /(?:pubsub|client)\.topic\s*\(\s*([^)]+)\)\s*\.publish/g;
+            while ((match = topicPublishRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `pubsub-producer-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'pubsub',
+                    nodeType: 'producer',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+            // const topic = pubsub.topic('topicName')
+            const topicRefRegex = /(?:pubsub|client)\.topic\s*\(\s*([^)]+)\)/g;
+            while ((match = topicRefRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                // Only add as topic-definition if not already captured as producer
+                nodes.push({
+                    id: `pubsub-topic-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'pubsub',
+                    nodeType: 'topic-definition',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+            // subscription.on('message', ...) or pubsub.subscription('subName').on(...)
+            const subscriptionRegex = /(?:pubsub|client)\.subscription\s*\(\s*([^)]+)\)/g;
+            while ((match = subscriptionRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `pubsub-consumer-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'pubsub',
+                    nodeType: 'consumer',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+        }
+        catch {
+            // never throws
+        }
+        return nodes;
+    }
+}
+exports.PubsubDetector = PubsubDetector;

package/dist/src/streaming/detectors/rabbitmqDetector.d.ts

@@ -0,0 +1,5 @@
+import type { EventNode } from '../types';
+export declare class RabbitmqDetector {
+    detect(fileContent: string, filePath: string): EventNode[];
+}
+//# sourceMappingURL=rabbitmqDetector.d.ts.map

package/dist/src/streaming/detectors/rabbitmqDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rabbitmqDetector.d.ts","sourceRoot":"","sources":["../../../../src/streaming/detectors/rabbitmqDetector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAmB,MAAM,UAAU,CAAC;AAsB3D,qBAAa,gBAAgB;IAC3B,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE;CAgF3D"}

package/dist/src/streaming/detectors/rabbitmqDetector.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitmqDetector = void 0;
+function resolveTopicString(raw) {
+    var _a;
+    const trimmed = raw.trim();
+    const envMatch = (_a = trimmed.match(/process\.env\.([A-Z_a-z][A-Z_a-z0-9]*)/)) !== null && _a !== void 0 ? _a : trimmed.match(/process\.env\[['"]([A-Z_a-z][A-Z_a-z0-9]*)['"]\]/);
+    if (envMatch) {
+        return { topic: `UNRESOLVED:env:${envMatch[1]}`, resolution: `UNRESOLVED:env:${envMatch[1]}` };
+    }
+    if (trimmed.includes('${')) {
+        return { topic: 'UNRESOLVED:dynamic', resolution: 'UNRESOLVED:dynamic' };
+    }
+    const literalMatch = trimmed.match(/^['"`]([^'"`]+)['"`]$/);
+    if (literalMatch) {
+        return { topic: literalMatch[1], resolution: 'resolved' };
+    }
+    if (trimmed.match(/^[A-Za-z_][A-Za-z_0-9.]*$/)) {
+        return { topic: trimmed, resolution: 'cross-file-unresolved' };
+    }
+    return { topic: 'UNRESOLVED:dynamic', resolution: 'UNRESOLVED:dynamic' };
+}
+class RabbitmqDetector {
+    detect(fileContent, filePath) {
+        var _a, _b;
+        const nodes = [];
+        try {
+            let idx = 0;
+            // channel.sendToQueue('queueName', ...)
+            const sendToQueueRegex = /channel\.sendToQueue\s*\(\s*([^,)]+)/g;
+            let match;
+            while ((match = sendToQueueRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `rabbitmq-producer-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'rabbitmq',
+                    nodeType: 'producer',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+            // channel.assertQueue('queueName', ...)
+            const assertQueueRegex = /channel\.assertQueue\s*\(\s*([^,)]+)/g;
+            while ((match = assertQueueRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `rabbitmq-queue-def-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'rabbitmq',
+                    nodeType: 'topic-definition',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+            // channel.consume('queueName', ...) — consumer
+            const consumeRegex = /channel\.consume\s*\(\s*([^,)]+)/g;
+            while ((match = consumeRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `rabbitmq-consumer-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'rabbitmq',
+                    nodeType: 'consumer',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+            // @RabbitListener(queues = "queueName") or @RabbitMQListener
+            const rabbitListenerRegex = /@Rabbit(?:Listener|MQListener)\s*\([^)]*queues?\s*=\s*(?:\{([^}]*)\}|([^,)"]+|"[^"]*"))/g;
+            while ((match = rabbitListenerRegex.exec(fileContent)) !== null) {
+                const rawTopics = (_b = (_a = match[1]) !== null && _a !== void 0 ? _a : match[2]) !== null && _b !== void 0 ? _b : '';
+                const topicItems = match[1]
+                    ? rawTopics.split(',').map((t) => t.trim()).filter(Boolean)
+                    : [rawTopics.trim()];
+                for (const topicRaw of topicItems) {
+                    const { topic, resolution } = resolveTopicString(topicRaw);
+                    nodes.push({
+                        id: `rabbitmq-listener-${filePath}-${idx++}`,
+                        filePath,
+                        brokerType: 'rabbitmq',
+                        nodeType: 'consumer',
+                        topic,
+                        resolution,
+                        hasTest: false,
+                        testFiles: [],
+                    });
+                }
+            }
+        }
+        catch {
+            // never throws
+        }
+        return nodes;
+    }
+}
+exports.RabbitmqDetector = RabbitmqDetector;

package/dist/src/streaming/detectors/redisPubsubDetector.d.ts

@@ -0,0 +1,5 @@
+import type { EventNode } from '../types';
+export declare class RedisPubsubDetector {
+    detect(fileContent: string, filePath: string): EventNode[];
+}
+//# sourceMappingURL=redisPubsubDetector.d.ts.map

package/dist/src/streaming/detectors/redisPubsubDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redisPubsubDetector.d.ts","sourceRoot":"","sources":["../../../../src/streaming/detectors/redisPubsubDetector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAmB,MAAM,UAAU,CAAC;AAsB3D,qBAAa,mBAAmB;IAC9B,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE;CA0D3D"}

package/dist/src/streaming/detectors/redisPubsubDetector.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisPubsubDetector = void 0;
+function resolveTopicString(raw) {
+    var _a;
+    const trimmed = raw.trim();
+    const envMatch = (_a = trimmed.match(/process\.env\.([A-Z_a-z][A-Z_a-z0-9]*)/)) !== null && _a !== void 0 ? _a : trimmed.match(/process\.env\[['"]([A-Z_a-z][A-Z_a-z0-9]*)['"]\]/);
+    if (envMatch) {
+        return { topic: `UNRESOLVED:env:${envMatch[1]}`, resolution: `UNRESOLVED:env:${envMatch[1]}` };
+    }
+    if (trimmed.includes('${')) {
+        return { topic: 'UNRESOLVED:dynamic', resolution: 'UNRESOLVED:dynamic' };
+    }
+    const literalMatch = trimmed.match(/^['"`]([^'"`]+)['"`]$/);
+    if (literalMatch) {
+        return { topic: literalMatch[1], resolution: 'resolved' };
+    }
+    if (trimmed.match(/^[A-Za-z_][A-Za-z_0-9.]*$/)) {
+        return { topic: trimmed, resolution: 'cross-file-unresolved' };
+    }
+    return { topic: 'UNRESOLVED:dynamic', resolution: 'UNRESOLVED:dynamic' };
+}
+class RedisPubsubDetector {
+    detect(fileContent, filePath) {
+        const nodes = [];
+        try {
+            let idx = 0;
+            let match;
+            // redis.publish('channel', message) or publisher.publish('channel', ...)
+            const publishRegex = /(?:redis|publisher|pub|client)\.publish\s*\(\s*([^,)]+)/g;
+            while ((match = publishRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `redis-pubsub-producer-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'redis-pubsub',
+                    nodeType: 'producer',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+            // redis.subscribe('channel', callback) or subscriber.subscribe('channel', ...)
+            const subscribeRegex = /(?:redis|subscriber|sub|client)\.subscribe\s*\(\s*([^,)]+)/g;
+            while ((match = subscribeRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `redis-pubsub-consumer-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'redis-pubsub',
+                    nodeType: 'consumer',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+            // redis.psubscribe('pattern*', callback) — pattern subscribe
+            const psubscribeRegex = /(?:redis|subscriber|sub|client)\.psubscribe\s*\(\s*([^,)]+)/g;
+            while ((match = psubscribeRegex.exec(fileContent)) !== null) {
+                const { topic, resolution } = resolveTopicString(match[1]);
+                nodes.push({
+                    id: `redis-pubsub-psubscribe-${filePath}-${idx++}`,
+                    filePath,
+                    brokerType: 'redis-pubsub',
+                    nodeType: 'consumer',
+                    topic,
+                    resolution,
+                    hasTest: false,
+                    testFiles: [],
+                });
+            }
+        }
+        catch {
+            // never throws
+        }
+        return nodes;
+    }
+}
+exports.RedisPubsubDetector = RedisPubsubDetector;

package/dist/src/streaming/detectors/snsDetector.d.ts

@@ -0,0 +1,5 @@
+import type { EventNode } from '../types';
+export declare class SnsDetector {
+    detect(fileContent: string, filePath: string): EventNode[];
+}
+//# sourceMappingURL=snsDetector.d.ts.map

package/dist/src/streaming/detectors/snsDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snsDetector.d.ts","sourceRoot":"","sources":["../../../../src/streaming/detectors/snsDetector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAmB,MAAM,UAAU,CAAC;AAsB3D,qBAAa,WAAW;IACtB,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE;CA0D3D"}