@ductape/sdk 0.1.8 → 0.1.10

package/dist/brokers/brokers.service.js

@@ -0,0 +1,1315 @@
+"use strict";
+/**
+ * BrokersService - Main Message Broker Service Class
+ *
+ * Provides a unified interface for message broker operations including
+ * publish and subscribe functionality.
+ *
+ * Supported providers: RabbitMQ, Kafka, AWS SQS, Redis, Google Pub/Sub
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrokersService = exports.BrokerError = void 0;
+const broker_util_1 = require("./utils/broker.util");
+const products_service_1 = __importDefault(require("../products/services/products.service"));
+const types_1 = require("../types");
+const logs_service_1 = __importDefault(require("../logs/logs.service"));
+const types_2 = require("../types");
+const processor_utils_1 = require("../processor/utils/processor.utils");
+const processorApi_service_1 = require("../api/services/processorApi.service");
+const secrets_1 = require("../secrets");
+const cloud_runtime_util_1 = require("../cloud/cloud-runtime.util");
+const cache_manager_1 = require("../cache/cache.manager");
+const sessions_1 = require("../sessions");
+/** Log prefix for broker operations */
+const LOG_PREFIX = '[BrokersService]';
+/** Shared broker services: one per workspace+product+poolKey. Not exported. */
+const sharedBrokerRegistry = new Map();
+const sharedBrokerInFlight = new Map();
+function getSharedBrokerKey(workspaceId, product, poolKey) {
+    return `${workspaceId}:${product}:${poolKey}`;
+}
+/**
+ * Error class for broker operations
+ */
+class BrokerError extends Error {
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'BrokerError';
+    }
+}
+exports.BrokerError = BrokerError;
+/**
+ * BrokersService
+ *
+ * Unified API for all message broker operations.
+ *
+ * @example
+ * ```ts
+ * import { BrokersService } from '@ductape/sdk';
+ *
+ * const brokers = new BrokersService({
+ *   workspace_id: 'your-workspace-id',
+ *   public_key: 'your-public-key',
+ *   user_id: 'your-user-id',
+ *   token: 'your-token',
+ *   env_type: 'prd',
+ * });
+ *
+ * // Publish a message
+ * await brokers.publish({
+ *   product: 'my-product',
+ *   env: 'production',
+ *   event: 'orders-broker:new-order',
+ *   message: { orderId: '123', amount: 99.99 },
+ * });
+ *
+ * // Subscribe to messages
+ * await brokers.subscribe({
+ *   product: 'my-product',
+ *   env: 'production',
+ *   event: 'orders-broker:new-order',
+ *   callback: async (message) => {
+ *     console.log('Received:', message);
+ *   },
+ * });
+ * ```
+ */
+class BrokersService {
+    constructor(config) {
+        var _a;
+        this.logService = null;
+        this.productId = '';
+        this.productTag = '';
+        this.privateKey = '';
+        /** Cache manager for 3-tier caching */
+        this.cacheManager = null;
+        /** Private keys per product for cache encryption */
+        this.privateKeys = new Map();
+        /** Connection pool for broker services - keyed by broker type + config hash */
+        this.brokerServicePool = new Map();
+        /** When using shared registry, track poolKey -> sharedKey so disconnectAll can remove from shared */
+        this.poolKeyToSharedKey = new Map();
+        /** Cache for initialized broker configs - keyed by "productTag:brokerTag:envSlug" */
+        this.initializedBrokerCache = new Map();
+        /** Cache for initialized products - keyed by productTag */
+        this.initializedProducts = new Set();
+        /** Cache for registered broker consumers - keyed by consumerTag to track which consumers have been registered */
+        this.registeredConsumers = new Set();
+        /** Local cache for cache configurations to avoid repeated API calls */
+        this.cacheConfigCache = new Map();
+        /** Dedupe "Publish to broker - success" when same event is published twice in quick succession (e.g. workflow step run twice) */
+        this.lastPublishSuccessLogKey = null;
+        this.lastPublishSuccessLogTime = 0;
+        // ============================================================================
+        // BROKER MESSAGE QUERY METHODS (for workbench with decryption)
+        // ============================================================================
+        /**
+         * Messages namespace for workbench broker message queries
+         * All methods decrypt message content before returning
+         */
+        this.messages = {
+            /**
+             * Query broker messages with filtering and pagination
+             * Decrypts message content before returning
+             */
+            query: async (options) => {
+                try {
+                    await this.initializeProductForEvents(options.product);
+                    const result = await this.processorApiService.queryBrokerMessages({
+                        product_tag: options.product,
+                        env: options.env,
+                        broker_tag: options.brokerTag,
+                        topic_tag: options.topicTag,
+                        producer_tag: options.producerTag,
+                        consumer_tag: options.consumerTag,
+                        status: options.status,
+                        start_date: options.startDate,
+                        end_date: options.endDate,
+                        page: options.page,
+                        limit: options.limit,
+                    }, this.getUserAccess());
+                    // Decrypt message content for each message
+                    const messages = result.messages.map((msg) => (Object.assign(Object.assign({}, msg), { message_decrypted: msg.message_encrypted
+                            ? this.decryptPayload(msg.message_encrypted)
+                            : undefined })));
+                    return {
+                        messages,
+                        total: result.total,
+                        page: result.page,
+                        limit: result.limit,
+                        hasMore: result.hasMore,
+                    };
+                }
+                catch (error) {
+                    if (error instanceof BrokerError)
+                        throw error;
+                    throw new BrokerError(`Failed to query broker messages: ${error}`, 'QUERY_MESSAGES_FAILED', error);
+                }
+            },
+            /**
+             * Get broker producers with pagination
+             */
+            getProducers: async (options) => {
+                try {
+                    await this.initializeProductForEvents(options.product);
+                    return await this.processorApiService.getBrokerProducers({
+                        product_tag: options.product,
+                        env: options.env,
+                        broker_tag: options.brokerTag,
+                        topic_tag: options.topicTag,
+                        page: options.page,
+                        limit: options.limit,
+                    }, this.getUserAccess());
+                }
+                catch (error) {
+                    if (error instanceof BrokerError)
+                        throw error;
+                    throw new BrokerError(`Failed to get broker producers: ${error}`, 'GET_PRODUCERS_FAILED', error);
+                }
+            },
+            /**
+             * Get broker consumers with pagination
+             */
+            getConsumers: async (options) => {
+                try {
+                    await this.initializeProductForEvents(options.product);
+                    return await this.processorApiService.getBrokerConsumers({
+                        product_tag: options.product,
+                        env: options.env,
+                        broker_tag: options.brokerTag,
+                        topic_tag: options.topicTag,
+                        page: options.page,
+                        limit: options.limit,
+                    }, this.getUserAccess());
+                }
+                catch (error) {
+                    if (error instanceof BrokerError)
+                        throw error;
+                    throw new BrokerError(`Failed to get broker consumers: ${error}`, 'GET_CONSUMERS_FAILED', error);
+                }
+            },
+            /**
+             * Get broker dead letters with pagination
+             * Decrypts message content before returning
+             */
+            getDeadLetters: async (options) => {
+                try {
+                    await this.initializeProductForEvents(options.product);
+                    const result = await this.processorApiService.getBrokerDeadLetters({
+                        product_tag: options.product,
+                        env: options.env,
+                        broker_tag: options.brokerTag,
+                        topic_tag: options.topicTag,
+                        consumer_tag: options.consumerTag,
+                        start_date: options.startDate,
+                        end_date: options.endDate,
+                        page: options.page,
+                        limit: options.limit,
+                    }, this.getUserAccess());
+                    // Decrypt message content for dead letters
+                    const deadLetters = result.deadLetters.map((dl) => (Object.assign(Object.assign({}, dl), { original_message: dl.original_message ? Object.assign(Object.assign({}, dl.original_message), { message_decrypted: dl.original_message.message_encrypted
+                                ? this.decryptPayload(dl.original_message.message_encrypted)
+                                : undefined }) : dl.original_message })));
+                    return {
+                        deadLetters,
+                        total: result.total,
+                        page: result.page,
+                        limit: result.limit,
+                        hasMore: result.hasMore,
+                    };
+                }
+                catch (error) {
+                    if (error instanceof BrokerError)
+                        throw error;
+                    throw new BrokerError(`Failed to get broker dead letters: ${error}`, 'GET_DEAD_LETTERS_FAILED', error);
+                }
+            },
+            /**
+             * Get comprehensive broker message statistics
+             */
+            getStats: async (options) => {
+                try {
+                    await this.initializeProductForEvents(options.product);
+                    return await this.processorApiService.getBrokerComprehensiveStats({
+                        product_tag: options.product,
+                        env: options.env,
+                        broker_tag: options.brokerTag,
+                    }, this.getUserAccess());
+                }
+                catch (error) {
+                    if (error instanceof BrokerError)
+                        throw error;
+                    throw new BrokerError(`Failed to get broker stats: ${error}`, 'GET_STATS_FAILED', error);
+                }
+            },
+            /**
+             * Get broker dashboard overview data
+             * Decrypts message content for recent messages
+             */
+            getDashboard: async (options) => {
+                try {
+                    await this.initializeProductForEvents(options.product);
+                    const result = await this.processorApiService.getBrokerDashboard({
+                        product_tag: options.product,
+                        env: options.env,
+                        broker_tag: options.brokerTag,
+                    }, this.getUserAccess());
+                    // Decrypt recent messages
+                    const recentMessages = (result.recent_messages || []).map((msg) => (Object.assign(Object.assign({}, msg), { message_decrypted: msg.message_encrypted
+                            ? this.decryptPayload(msg.message_encrypted)
+                            : undefined })));
+                    return Object.assign(Object.assign({}, result), { recent_messages: recentMessages });
+                }
+                catch (error) {
+                    if (error instanceof BrokerError)
+                        throw error;
+                    throw new BrokerError(`Failed to get broker dashboard: ${error}`, 'GET_DASHBOARD_FAILED', error);
+                }
+            },
+        };
+        this.config = config;
+        this.productBuilderService = (_a = config.preInitializedProductBuilder) !== null && _a !== void 0 ? _a : new products_service_1.default({
+            workspace_id: config.workspace_id,
+            public_key: config.public_key,
+            user_id: config.user_id,
+            token: config.token,
+            env_type: config.env_type,
+            redis_client: config.redis_client,
+            access_key: config.access_key,
+        });
+        this.processorApiService = new processorApi_service_1.ProcessorApiService(config.env_type);
+        // Initialize CacheManager if Redis client is provided
+        if (config.redis_client) {
+            this.cacheManager = new cache_manager_1.CacheManager({
+                workspace_id: config.workspace_id,
+                public_key: config.public_key,
+                user_id: config.user_id,
+                token: config.token,
+                env_type: config.env_type || '',
+                redis_client: config.redis_client,
+            });
+        }
+    }
+    /**
+     * Get user access credentials
+     */
+    getUserAccess() {
+        return {
+            user_id: this.config.user_id,
+            token: this.config.token,
+            workspace_id: this.config.workspace_id,
+            public_key: this.config.public_key,
+            access_key: this.config.access_key,
+        };
+    }
+    /**
+     * Initialize product and get broker configuration (with caching)
+     */
+    async initializeBroker(productTag, envSlug, event, message) {
+        var _a, _b;
+        // Parse event to get broker and topic tags
+        const { brokerTag, topicTag } = (0, broker_util_1.parseEventString)(event);
+        // Check cache first (keyed by product:broker:env)
+        const cacheKey = `${productTag}:${brokerTag}:${envSlug}`;
+        const cached = this.initializedBrokerCache.get(cacheKey);
+        if (cached) {
+            // For cached brokers, just check if topic exists (might be new topic)
+            let topic = (_a = cached.broker.topics) === null || _a === void 0 ? void 0 : _a.find(t => t.tag === topicTag);
+            if (!topic) {
+                if (message) {
+                    this.ensureTopicRegistered(brokerTag, topicTag, message);
+                }
+                topic = { tag: topicTag, name: topicTag, sample: message || {} };
+            }
+            // Determine topic URL
+            let topicUrl = topic.name;
+            if (cached.brokerEnv.type === types_1.MessageBrokerTypes.AWS_SQS) {
+                topicUrl = (0, broker_util_1.getSqsQueueUrl)(topic, envSlug);
+            }
+            return Object.assign(Object.assign({}, cached), { topic, topicUrl });
+        }
+        // Initialize product only if not already done
+        if (!this.initializedProducts.has(productTag)) {
+            await this.productBuilderService.initializeProductByTag(productTag);
+            this.initializedProducts.add(productTag);
+        }
+        this.productTag = productTag;
+        this.productId = this.productBuilderService.fetchProductId() || '';
+        this.privateKey = this.productBuilderService.fetchPrivateKey();
+        // Fetch broker configuration
+        const broker = await this.productBuilderService.fetchMessageBroker(brokerTag);
+        if (!broker) {
+            throw new BrokerError(`Message Broker ${brokerTag} not found`, 'BROKER_NOT_FOUND');
+        }
+        if (!broker.envs || !Array.isArray(broker.envs)) {
+            throw new BrokerError(`Message Broker ${brokerTag} has no environments configured`, 'BROKER_NO_ENVS');
+        }
+        // Get environment-specific broker config
+        const brokerEnv = broker.envs.find((el) => el.slug === envSlug);
+        if (!brokerEnv) {
+            throw new BrokerError(`Broker environment for ${envSlug} not found`, 'BROKER_ENV_NOT_FOUND');
+        }
+        // Check if topic exists in broker's topics array
+        let topic = (_b = broker.topics) === null || _b === void 0 ? void 0 : _b.find(t => t.tag === topicTag);
+        if (!topic) {
+            if (message) {
+                this.ensureTopicRegistered(brokerTag, topicTag, message);
+            }
+            topic = { tag: topicTag, name: topicTag, sample: message || {} };
+        }
+        // Resolve $Secret{} and refresh cloud_connection credentials when linked
+        let resolvedConfig = brokerEnv.config;
+        if (resolvedConfig && typeof resolvedConfig === 'object') {
+            try {
+                resolvedConfig = (await (0, cloud_runtime_util_1.resolveCloudLinkedConfig)(resolvedConfig, {
+                    environment: this.config.env_type,
+                    auth: {
+                        token: this.config.token,
+                        public_key: this.config.public_key,
+                        user_id: this.config.user_id,
+                        workspace_id: this.config.workspace_id,
+                        access_key: this.config.access_key,
+                    },
+                    productTag,
+                    componentTag: brokerTag,
+                    envSlug,
+                }));
+            }
+            catch (err) {
+                if ((0, secrets_1.mightContainSecrets)(resolvedConfig)) {
+                    const secretsService = (0, secrets_1.getSecretsService)();
+                    if (!secretsService) {
+                        throw new BrokerError(`Broker configuration contains secret references but secrets service is not initialized.`, 'SECRETS_NOT_INITIALIZED');
+                    }
+                    const resolved = await secretsService.resolve(resolvedConfig, { env: envSlug });
+                    resolvedConfig = resolved.value;
+                }
+                else {
+                    throw new BrokerError(`Failed to resolve cloud-linked broker config: ${err.message}`, 'CLOUD_CONFIG_RESOLVE_ERROR', err);
+                }
+            }
+        }
+        // Create resolved broker env
+        const resolvedBrokerEnv = Object.assign(Object.assign({}, brokerEnv), { config: resolvedConfig });
+        // Determine the topic URL/name
+        let topicUrl = topic.name;
+        if (brokerEnv.type === types_1.MessageBrokerTypes.AWS_SQS) {
+            topicUrl = (0, broker_util_1.getSqsQueueUrl)(topic, envSlug);
+        }
+        // Cache the result (without topic, as topics may vary per call)
+        this.initializedBrokerCache.set(cacheKey, {
+            broker,
+            topic, // Store last topic, but will be re-evaluated on cache hit
+            brokerEnv: resolvedBrokerEnv,
+            topicUrl,
+        });
+        return { broker, topic, brokerEnv: resolvedBrokerEnv, topicUrl };
+    }
+    /**
+     * Initialize logging service
+     */
+    initializeLogService() {
+        if (!this.logService) {
+            this.logService = new logs_service_1.default({
+                product_id: this.productId,
+                workspace_id: this.config.workspace_id,
+                public_key: this.config.public_key,
+                user_id: this.config.user_id,
+                token: this.config.token,
+                env_type: this.config.env_type,
+                workspace_private_key: this.config.workspace_private_key,
+            });
+        }
+    }
+    /**
+     * Validate cache tag exists in product and return cache configuration
+     * Uses local in-memory cache to avoid repeated API calls (5 minute TTL)
+     */
+    async validateCache(cacheTag) {
+        const cacheKey = `${this.productTag}:${cacheTag}`;
+        const cached = this.cacheConfigCache.get(cacheKey);
+        const now = Date.now();
+        const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+        // Return cached config if still valid
+        if (cached && (now - cached.fetchedAt) < CACHE_TTL) {
+            return { expiry: cached.expiry };
+        }
+        // Fetch from API and cache the result
+        const cache = await this.productBuilderService.fetchCache(cacheTag);
+        if (!cache) {
+            throw new BrokerError(`Cache configuration '${cacheTag}' does not exist`, 'CACHE_NOT_FOUND');
+        }
+        this.cacheConfigCache.set(cacheKey, { expiry: cache.expiry, fetchedAt: now });
+        return { expiry: cache.expiry };
+    }
+    /**
+     * Generate a cache key for the broker service pool
+     */
+    getBrokerPoolKey(type, config) {
+        var _a;
+        // Use type + url/host as the key (url for RabbitMQ, host for others)
+        const configKey = (config === null || config === void 0 ? void 0 : config.url) || (config === null || config === void 0 ? void 0 : config.host) || ((_a = config === null || config === void 0 ? void 0 : config.brokers) === null || _a === void 0 ? void 0 : _a[0]) || JSON.stringify(config);
+        return `${type}:${configKey}`;
+    }
+    /**
+     * Get or create broker service instance (with connection pooling).
+     * When scope.workspaceId and scope.product are provided, uses shared registry so connections are reused across instances.
+     */
+    async getBrokerService(type, config, scope) {
+        var _a, _b;
+        if ((0, broker_util_1.isBrowser)()) {
+            throw new BrokerError('Broker operations are not supported in browser environment', 'BROWSER_NOT_SUPPORTED');
+        }
+        const poolKey = this.getBrokerPoolKey(type, config);
+        const existingService = this.brokerServicePool.get(poolKey);
+        if (existingService)
+            return existingService;
+        const workspaceId = (_a = scope === null || scope === void 0 ? void 0 : scope.workspaceId) !== null && _a !== void 0 ? _a : '';
+        const product = (_b = scope === null || scope === void 0 ? void 0 : scope.product) !== null && _b !== void 0 ? _b : '';
+        const useShared = workspaceId !== '' && product !== '';
+        if (useShared) {
+            const sharedKey = getSharedBrokerKey(workspaceId, product, poolKey);
+            const existing = sharedBrokerRegistry.get(sharedKey);
+            if (existing) {
+                this.brokerServicePool.set(poolKey, existing);
+                this.poolKeyToSharedKey.set(poolKey, sharedKey);
+                return existing;
+            }
+            const inFlight = sharedBrokerInFlight.get(sharedKey);
+            if (inFlight) {
+                const service = await inFlight;
+                this.brokerServicePool.set(poolKey, service);
+                this.poolKeyToSharedKey.set(poolKey, sharedKey);
+                return service;
+            }
+            const createPromise = (async () => {
+                const existingInRegistry = sharedBrokerRegistry.get(sharedKey);
+                if (existingInRegistry) {
+                    try {
+                        if (typeof existingInRegistry.disconnect === 'function')
+                            await existingInRegistry.disconnect();
+                    }
+                    catch (_a) {
+                        // Non-fatal
+                    }
+                    sharedBrokerRegistry.delete(sharedKey);
+                }
+                const createBrokerService = await (0, broker_util_1.loadBrokerService)();
+                if (!createBrokerService) {
+                    throw new BrokerError('Failed to load broker service', 'BROKER_SERVICE_LOAD_FAILED');
+                }
+                const service = createBrokerService(type, config);
+                const raceExisting = sharedBrokerRegistry.get(sharedKey);
+                if (raceExisting) {
+                    try {
+                        if (typeof raceExisting.disconnect === 'function')
+                            await raceExisting.disconnect();
+                    }
+                    catch (_b) {
+                        // Non-fatal
+                    }
+                    sharedBrokerRegistry.delete(sharedKey);
+                }
+                sharedBrokerRegistry.set(sharedKey, service);
+                return service;
+            })();
+            sharedBrokerInFlight.set(sharedKey, createPromise);
+            try {
+                const service = await createPromise;
+                this.brokerServicePool.set(poolKey, service);
+                this.poolKeyToSharedKey.set(poolKey, sharedKey);
+                return service;
+            }
+            finally {
+                sharedBrokerInFlight.delete(sharedKey);
+            }
+        }
+        const createBrokerService = await (0, broker_util_1.loadBrokerService)();
+        if (!createBrokerService) {
+            throw new BrokerError('Failed to load broker service', 'BROKER_SERVICE_LOAD_FAILED');
+        }
+        const service = createBrokerService(type, config);
+        this.brokerServicePool.set(poolKey, service);
+        return service;
+    }
+    /**
+     * Disconnect all pooled broker connections (e.g. at end of workflow run). Safe if pool is empty.
+     */
+    async disconnectAll() {
+        for (const [poolKey, service] of this.brokerServicePool.entries()) {
+            try {
+                if (typeof service.disconnect === 'function')
+                    await service.disconnect();
+            }
+            catch (_a) {
+                // Non-fatal
+            }
+            const sharedKey = this.poolKeyToSharedKey.get(poolKey);
+            if (sharedKey)
+                sharedBrokerRegistry.delete(sharedKey);
+        }
+        this.brokerServicePool.clear();
+        this.poolKeyToSharedKey.clear();
+    }
+    /**
+     * Pre-warm broker connections for the given product/env and broker tags.
+     * Call before step execution so the first produce step reuses connections. Same auth and secrets as publish.
+     */
+    async warmBrokerConnections(options) {
+        var _a;
+        const { product, env, brokerTags } = options;
+        if (brokerTags.length === 0)
+            return;
+        for (const brokerTag of brokerTags) {
+            try {
+                const { brokerEnv } = await this.initializeBroker(product, env, `${brokerTag}:_warm`, {});
+                const service = await this.getBrokerService(brokerEnv.type, brokerEnv.config, {
+                    workspaceId: (_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id,
+                    product,
+                });
+                if (typeof service.connect === 'function')
+                    await service.connect();
+            }
+            catch (_b) {
+                // Non-fatal: step will connect on first use
+            }
+        }
+    }
+    /**
+     * Auto-register a topic in the background (fire-and-forget)
+     * This is intentionally lightweight - no pre-check, no post-fetch
+     */
+    ensureTopicRegistered(brokerTag, topicTag, message) {
+        const fullTag = `${brokerTag}:${topicTag}`;
+        // Fire-and-forget: don't await, let it run in background
+        this.productBuilderService.createMessageBrokerTopic({
+            tag: fullTag,
+            name: topicTag,
+            description: `Auto-registered topic for ${fullTag}`,
+            sample: JSON.stringify(message || {}),
+            idempotent: false,
+        }).catch(() => {
+            // Silently ignore - topic might already exist or registration failed
+            // Either way, the publish should proceed
+        });
+    }
+    /**
+     * Auto-register a producer if it doesn't exist
+     */
+    async ensureProducerRegistered(brokerTag, topicTag, options) {
+        const tag = (options === null || options === void 0 ? void 0 : options.tag) || `producer-${brokerTag}-${topicTag}`;
+        const topic = `${brokerTag}:${topicTag}`;
+        try {
+            const existingProducer = await this.productBuilderService.fetchMessageBrokerProducer(brokerTag, tag);
+            if (!existingProducer) {
+                await this.productBuilderService.createMessageBrokerProducer({
+                    tag,
+                    topic,
+                    description: (options === null || options === void 0 ? void 0 : options.description) || `Auto-registered producer for ${topic}`,
+                });
+            }
+        }
+        catch (_a) {
+            // Silently ignore registration errors - the main operation should still proceed
+        }
+    }
+    /**
+     * Auto-register a consumer if it doesn't exist
+     */
+    async ensureConsumerRegistered(brokerTag, topicTag, options) {
+        const tag = (options === null || options === void 0 ? void 0 : options.tag) || `consumer-${brokerTag}-${topicTag}`;
+        const topic = `${brokerTag}:${topicTag}`;
+        try {
+            const existingConsumer = await this.productBuilderService.fetchMessageBrokerConsumer(brokerTag, tag);
+            if (!existingConsumer) {
+                await this.productBuilderService.createMessageBrokerConsumer({
+                    tag,
+                    topic,
+                    description: (options === null || options === void 0 ? void 0 : options.description) || `Auto-registered consumer for ${topic}`,
+                });
+            }
+        }
+        catch (_a) {
+            // Silently ignore registration errors - the main operation should still proceed
+        }
+    }
+    /**
+     * Publish a message to a broker topic
+     */
+    async publish(options) {
+        var _a, _b, _c, _d, _e;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        const start = Date.now();
+        const { cache } = options;
+        let sessionLogFields = {};
+        let resolvedMessage = options.message;
+        // Parse event string early to have broker/topic tags available for error logging
+        const { brokerTag, topicTag } = (0, broker_util_1.parseEventString)(options.event);
+        try {
+            const { broker, topic, brokerEnv, topicUrl } = await this.initializeBroker(options.product, options.env, options.event, options.message);
+            // Store private key for cache operations
+            if (this.privateKey) {
+                this.privateKeys.set(options.product, this.privateKey);
+            }
+            // Process session if provided - verify and resolve $Session{} references
+            if (options.session && this.privateKey) {
+                // Convert session object { tag, token } to string format "tag:token"
+                const sessionToken = `${options.session.tag}:${options.session.token}`;
+                const sessionResult = await (0, sessions_1.processSessionForExecution)(sessionToken, this.privateKey, { message: options.message }, options.env, {
+                    fetchSessionSelector: async (sessionTag) => {
+                        const sessionConfig = await this.productBuilderService.fetchSession(sessionTag);
+                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
+                    },
+                });
+                if (sessionResult.error) {
+                    throw new BrokerError(`Session validation failed: ${sessionResult.error}`, 'SESSION_INVALID');
+                }
+                sessionLogFields = sessionResult.logFields;
+                resolvedMessage = sessionResult.input.message;
+            }
+            // Auto-register producer if not exists
+            await this.ensureProducerRegistered(brokerTag, topicTag, options.producer);
+            this.initializeLogService();
+            const baseLogs = Object.assign({ product_tag: options.product, product_id: this.productId, workspace_id: this.config.workspace_id, env: options.env, process_id, type: types_2.LogEventTypes.PRODUCER, parent_tag: brokerTag, child_tag: topicTag, data: { event: options.event } }, sessionLogFields);
+            this.logService.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Publish to broker - initiated', status: types_2.LogEventStatus.PROCESSING }));
+            // Check cache for idempotency (prevent duplicate publishes with same data)
+            if (cache && this.cacheManager && this.privateKey) {
+                const cacheConfig = await this.validateCache(cache);
+                const cacheOptions = {
+                    cache_tag: cache,
+                    product_tag: options.product,
+                    component_tag: `${brokerTag}:${topicTag}`,
+                    component_type: 'broker',
+                    operation: 'publish',
+                    input: { event: options.event, message: options.message },
+                    privateKey: this.privateKey,
+                    expiry: cacheConfig.expiry,
+                };
+                const cached = await this.cacheManager.fetch(cacheOptions);
+                if (cached.hit && cached.data) {
+                    const end = Date.now();
+                    this.logService.add(Object.assign(Object.assign({}, baseLogs), { start,
+                        end, message: `Publish to broker - cache hit (${cached.source})`, successful_execution: true, status: types_2.LogEventStatus.SUCCESS, data: { event: options.event, cache_source: cached.source }, cache_tag: cache, cache_key: cached.key, cache_status: true }));
+                    this.logService.publish();
+                    return cached.data;
+                }
+            }
+            // Generate message_id client-side and track asynchronously (fire-and-forget)
+            const producerTag = ((_a = options.producer) === null || _a === void 0 ? void 0 : _a.tag) || `producer-${brokerTag}-${topicTag}`;
+            const messageId = (0, processor_utils_1.generateObjectId)();
+            // Encrypt message on SDK side - NEVER send private_key over HTTP
+            const messageEncrypted = (0, processor_utils_1.encrypt)(JSON.stringify(resolvedMessage), this.privateKey);
+            // Track the message in the database (fire-and-forget - no await)
+            this.processorApiService.trackBrokerMessage({
+                workspace_id: this.config.workspace_id,
+                product_id: this.productId,
+                product_tag: options.product,
+                env: options.env,
+                broker_tag: brokerTag,
+                topic_tag: topicTag,
+                event: options.event,
+                producer_tag: producerTag,
+                message_encrypted: messageEncrypted,
+                process_id,
+                session_tag: (_b = options.session) === null || _b === void 0 ? void 0 : _b.tag,
+                metadata: { cache: options.cache },
+                message_id: messageId,
+            }, this.getUserAccess()).catch(() => {
+                // Silently ignore tracking errors - non-blocking
+            });
+            // Add the message_id to the message so consumers can track it
+            const messageWithTracking = Object.assign(Object.assign({}, resolvedMessage), { __ductape_message_id: messageId });
+            // Get broker service and publish
+            const brokerService = await this.getBrokerService(brokerEnv.type, brokerEnv.config, {
+                workspaceId: (_c = this.config) === null || _c === void 0 ? void 0 : _c.workspace_id,
+                product: options.product,
+            });
+            if (typeof brokerService.connect === 'function')
+                await brokerService.connect();
+            await brokerService.publish(topicUrl, messageWithTracking);
+            const result = {
+                success: true,
+                process_id,
+            };
+            // Store in cache for idempotency (fire-and-forget)
+            if (cache && this.cacheManager && this.privateKey) {
+                const cacheConfig = await this.validateCache(cache);
+                this.cacheManager.store({
+                    cache_tag: cache,
+                    product_tag: options.product,
+                    component_tag: `${brokerTag}:${topicTag}`,
+                    component_type: 'broker',
+                    operation: 'publish',
+                    input: { event: options.event, message: options.message },
+                    privateKey: this.privateKey,
+                    expiry: cacheConfig.expiry,
+                }, result);
+            }
+            const end = Date.now();
+            const successLogKey = `${options.product}:${options.env}:${options.event}`;
+            const now = Date.now();
+            const isDuplicateSuccessLog = this.lastPublishSuccessLogKey === successLogKey &&
+                now - this.lastPublishSuccessLogTime < BrokersService.PUBLISH_SUCCESS_LOG_DEDUPE_MS;
+            if (!isDuplicateSuccessLog) {
+                this.logService.add(Object.assign(Object.assign({}, baseLogs), { start,
+                    end, message: 'Publish to broker - success', successful_execution: true, status: types_2.LogEventStatus.SUCCESS }));
+                this.lastPublishSuccessLogKey = successLogKey;
+                this.lastPublishSuccessLogTime = now;
+            }
+            this.logService.publish();
+            return result;
+        }
+        catch (error) {
+            const end = Date.now();
+            this.initializeLogService();
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.add(Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id,
+                start,
+                end, type: types_2.LogEventTypes.PRODUCER, parent_tag: brokerTag, child_tag: topicTag, message: 'Publish to broker - failed', failed_execution: true, data: { event: options.event, error: String(error) }, status: types_2.LogEventStatus.FAIL }, sessionLogFields));
+            await ((_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish());
+            if (error instanceof BrokerError) {
+                throw error;
+            }
+            throw new BrokerError(`Failed to publish message: ${error}`, 'PUBLISH_FAILED', error);
+        }
+    }
+    /**
+     * Subscribe to a broker topic
+     */
+    async subscribe(options) {
+        var _a, _b, _c, _d;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        const start = Date.now();
+        try {
+            // For subscribe, we don't auto-register topics - they should already exist
+            const { broker, topic, brokerEnv, topicUrl } = await this.initializeBroker(options.product, options.env, options.event, undefined);
+            const { brokerTag, topicTag } = (0, broker_util_1.parseEventString)(options.event);
+            // Auto-register consumer if not exists
+            await this.ensureConsumerRegistered(brokerTag, topicTag, options.consumer);
+            this.initializeLogService();
+            const baseLogs = {
+                product_tag: options.product,
+                product_id: this.productId,
+                workspace_id: this.config.workspace_id,
+                env: options.env,
+                process_id,
+                type: types_2.LogEventTypes.CONSUMER,
+                parent_tag: brokerTag,
+                child_tag: topicTag,
+                data: { event: options.event },
+            };
+            this.logService.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Subscribe to broker - initiated', status: types_2.LogEventStatus.PROCESSING }));
+            // Get broker service and subscribe with message tracking wrapper
+            const brokerService = await this.getBrokerService(brokerEnv.type, brokerEnv.config, {
+                workspaceId: (_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id,
+                product: options.product,
+            });
+            if (typeof brokerService.connect === 'function')
+                await brokerService.connect();
+            const consumerTag = ((_b = options.consumer) === null || _b === void 0 ? void 0 : _b.tag) || `consumer-${brokerTag}-${topicTag}`;
+            // Pre-cache user access for callback use (avoid repeated calls)
+            const userAccess = this.getUserAccess();
+            // Wrap the callback to track message consumption (optimized for low latency)
+            const wrappedCallback = async (message) => {
+                const messageReceiveTime = Date.now();
+                const consumeProcessId = (0, processor_utils_1.generateObjectId)();
+                // Extract message_id from the message
+                const msgWithId = message;
+                const messageId = msgWithId.__ductape_message_id;
+                // Execute user callback FIRST - this is the critical path
+                let callbackSuccess = true;
+                let callbackError;
+                try {
+                    await options.callback(message);
+                }
+                catch (err) {
+                    callbackSuccess = false;
+                    callbackError = err;
+                }
+                const callbackEnd = Date.now();
+                // Fire-and-forget: All tracking/logging happens async after callback completes
+                // This ensures user callback latency is not affected by our tracking overhead
+                setImmediate(() => {
+                    var _a, _b;
+                    const consumeBaseLogs = {
+                        product_tag: options.product,
+                        product_id: this.productId,
+                        workspace_id: this.config.workspace_id,
+                        env: options.env,
+                        process_id: consumeProcessId,
+                        type: types_2.LogEventTypes.CONSUMER,
+                        parent_tag: brokerTag,
+                        child_tag: topicTag,
+                        data: { event: options.event, message_id: messageId, consumer_tag: consumerTag },
+                    };
+                    if (messageId) {
+                        // Calculate actual callback processing time
+                        const processingTime = callbackEnd - messageReceiveTime;
+                        // Register consumer first, then update status (sequential to avoid race condition)
+                        this.processorApiService.registerBrokerConsumer({
+                            message_id: messageId,
+                            consumer_tag: consumerTag,
+                        }, userAccess).then(() => {
+                            // Now update the status with processing time
+                            return this.processorApiService.updateBrokerConsumerStatus({
+                                message_id: messageId,
+                                consumer_tag: consumerTag,
+                                status: callbackSuccess ? 'success' : 'failed',
+                                error: callbackError ? String(callbackError) : undefined,
+                                processing_time: processingTime,
+                            }, userAccess);
+                        }).catch(() => { }); // Silently ignore tracking errors
+                    }
+                    // Log consumption (fire-and-forget)
+                    (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add(Object.assign(Object.assign(Object.assign({}, consumeBaseLogs), { start: messageReceiveTime, end: callbackEnd, message: messageId
+                            ? (callbackSuccess ? 'Message consumed - success' : 'Message consumed - failed')
+                            : 'Message consumed - untracked (no message_id)', successful_execution: callbackSuccess, failed_execution: !callbackSuccess, status: callbackSuccess ? types_2.LogEventStatus.SUCCESS : types_2.LogEventStatus.FAIL }), (callbackError && { data: Object.assign(Object.assign({}, consumeBaseLogs.data), { error: String(callbackError) }) })));
+                    (_b = this.logService) === null || _b === void 0 ? void 0 : _b.publish();
+                });
+                // Re-throw callback error if any (so RabbitMQ can handle retry/nack)
+                if (callbackError) {
+                    throw callbackError;
+                }
+            };
+            await brokerService.subscribe(topicUrl, wrappedCallback);
+            const end = Date.now();
+            this.logService.add(Object.assign(Object.assign({}, baseLogs), { start,
+                end, message: 'Subscribe to broker - success', successful_execution: true, status: types_2.LogEventStatus.SUCCESS }));
+            this.logService.publish();
+            return {
+                success: true,
+                process_id,
+            };
+        }
+        catch (error) {
+            const end = Date.now();
+            this.initializeLogService();
+            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add({
+                product_tag: options.product,
+                workspace_id: this.config.workspace_id,
+                env: options.env,
+                process_id,
+                start,
+                end,
+                type: types_2.LogEventTypes.CONSUMER,
+                message: 'Subscribe to broker - failed',
+                failed_execution: true,
+                data: { event: options.event, error: String(error) },
+                status: types_2.LogEventStatus.FAIL,
+            });
+            await ((_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish());
+            if (error instanceof BrokerError) {
+                throw error;
+            }
+            throw new BrokerError(`Failed to subscribe: ${error}`, 'SUBSCRIBE_FAILED', error);
+        }
+    }
+    /**
+     * Get all message brokers for a product
+     */
+    async getBrokers(productTag) {
+        await this.productBuilderService.initializeProductByTag(productTag);
+        return this.productBuilderService.fetchMessageBrokers();
+    }
+    /**
+     * Get a specific message broker by tag
+     */
+    async getBroker(productTag, brokerTag) {
+        await this.productBuilderService.initializeProductByTag(productTag);
+        return this.productBuilderService.fetchMessageBroker(brokerTag);
+    }
+    /**
+     * Get all topics for a message broker
+     */
+    async getTopics(productTag, brokerTag) {
+        await this.productBuilderService.initializeProductByTag(productTag);
+        return this.productBuilderService.fetchMessageBrokerTopics(brokerTag);
+    }
+    /**
+     * Get a specific topic by event string (broker_tag:topic_tag)
+     */
+    async getTopic(productTag, event) {
+        await this.productBuilderService.initializeProductByTag(productTag);
+        return this.productBuilderService.fetchMessageBrokerTopic(event);
+    }
+    /**
+     * Test connection to a message broker
+     *
+     * Validates broker configuration and attempts to establish a connection.
+     *
+     * @example
+     * ```ts
+     * const result = await brokers.testConnection({
+     *   product: 'my-product',
+     *   env: 'prd',
+     *   broker: 'orders-broker',
+     * });
+     * console.log(result.connected); // true or false
+     * ```
+     */
+    async testConnection(options) {
+        var _a;
+        const startTime = Date.now();
+        try {
+            // Initialize product and fetch broker configuration
+            await this.productBuilderService.initializeProductByTag(options.product);
+            const broker = await this.productBuilderService.fetchMessageBroker(options.broker);
+            if (!broker) {
+                return {
+                    connected: false,
+                    latency: Date.now() - startTime,
+                    error: `Message Broker '${options.broker}' not found`,
+                };
+            }
+            // Get environment-specific broker config
+            const brokerEnv = broker.envs.find((el) => el.slug === options.env);
+            if (!brokerEnv) {
+                return {
+                    connected: false,
+                    latency: Date.now() - startTime,
+                    error: `Broker environment '${options.env}' not found`,
+                };
+            }
+            // Resolve any secret references in broker config
+            let resolvedConfig = brokerEnv.config;
+            if (resolvedConfig && (0, secrets_1.mightContainSecrets)(resolvedConfig)) {
+                const secretsService = (0, secrets_1.getSecretsService)();
+                if (secretsService) {
+                    const resolved = await secretsService.resolve(resolvedConfig, { env: options.env });
+                    resolvedConfig = resolved.value;
+                }
+                else {
+                    return {
+                        connected: false,
+                        latency: Date.now() - startTime,
+                        error: 'Broker configuration contains secret references but secrets service is not initialized',
+                    };
+                }
+            }
+            // Try to create and connect the broker service
+            const brokerService = await this.getBrokerService(brokerEnv.type, resolvedConfig, {
+                workspaceId: (_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id,
+                product: options.product,
+            });
+            // Attempt to connect
+            await brokerService.connect();
+            // Disconnect after successful test
+            await brokerService.disconnect();
+            return {
+                connected: true,
+                latency: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+                latency: Date.now() - startTime,
+                error: error.message,
+            };
+        }
+    }
+    // ============================================================================
+    // EVENT TRACKING METHODS
+    // ============================================================================
+    /**
+     * Initialize product for event operations (without broker/topic lookup)
+     */
+    async initializeProductForEvents(productTag) {
+        await this.productBuilderService.initializeProductByTag(productTag);
+        this.productTag = productTag;
+        this.productId = this.productBuilderService.fetchProductId() || '';
+        this.privateKey = this.productBuilderService.fetchPrivateKey();
+    }
+    /**
+     * Encrypt payload data using the product's private key
+     */
+    encryptPayload(data) {
+        return (0, processor_utils_1.encrypt)(JSON.stringify(data), this.privateKey);
+    }
+    /**
+     * Decrypt payload data using the product's private key
+     */
+    decryptPayload(encryptedData) {
+        try {
+            return JSON.parse((0, processor_utils_1.decrypt)(encryptedData, this.privateKey));
+        }
+        catch (_a) {
+            return {};
+        }
+    }
+    /**
+     * Get broker events with filtering and pagination
+     *
+     * @example
+     * ```ts
+     * const result = await brokers.getEvents({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   brokerTag: 'order-events',
+     *   status: 'failed',
+     *   page: 1,
+     *   limit: 20,
+     * });
+     *
+     * for (const event of result.events) {
+     *   console.log('Event:', event.id, event.status);
+     * }
+     * ```
+     */
+    async getEvents(options) {
+        var _a, _b;
+        try {
+            await this.initializeProductForEvents(options.product);
+            const result = await this.processorApiService.getBrokerEvents({
+                product: options.product,
+                env: options.env,
+                brokerTag: options.brokerTag,
+                topic: options.topic,
+                category: options.category,
+                status: options.status,
+                idempotent: options.idempotent,
+                startDate: (_a = options.startDate) === null || _a === void 0 ? void 0 : _a.toISOString(),
+                endDate: (_b = options.endDate) === null || _b === void 0 ? void 0 : _b.toISOString(),
+                page: options.page,
+                limit: options.limit,
+            }, this.getUserAccess());
+            // Decrypt request/response data for each event
+            const events = result.events.map((event) => (Object.assign(Object.assign({}, event), { timestamp: new Date(event.timestamp), request_data: event.request_data_encrypted
+                    ? this.decryptPayload(event.request_data_encrypted)
+                    : event.request_data, response_data: event.response_data_encrypted
+                    ? this.decryptPayload(event.response_data_encrypted)
+                    : event.response_data })));
+            return {
+                events,
+                total: result.total,
+                page: result.page,
+                limit: result.limit,
+                hasMore: result.hasMore,
+            };
+        }
+        catch (error) {
+            if (error instanceof BrokerError)
+                throw error;
+            throw new BrokerError(`Failed to get broker events: ${error}`, 'GET_EVENTS_FAILED', error);
+        }
+    }
+    /**
+     * Get a single broker event by ID
+     *
+     * @example
+     * ```ts
+     * const event = await brokers.getEvent({
+     *   product: 'my-product',
+     *   eventId: 'event-123',
+     * });
+     *
+     * if (event) {
+     *   console.log('Event status:', event.status);
+     *   console.log('Request data:', event.request_data);
+     * }
+     * ```
+     */
+    async getEvent(options) {
+        try {
+            await this.initializeProductForEvents(options.product);
+            const event = await this.processorApiService.getBrokerEvent({ product: options.product, eventId: options.eventId }, this.getUserAccess());
+            if (!event)
+                return null;
+            // Decrypt request/response data
+            return Object.assign(Object.assign({}, event), { timestamp: new Date(event.timestamp), request_data: event.request_data_encrypted
+                    ? this.decryptPayload(event.request_data_encrypted)
+                    : event.request_data, response_data: event.response_data_encrypted
+                    ? this.decryptPayload(event.response_data_encrypted)
+                    : event.response_data });
+        }
+        catch (error) {
+            if (error instanceof BrokerError)
+                throw error;
+            throw new BrokerError(`Failed to get broker event: ${error}`, 'GET_EVENT_FAILED', error);
+        }
+    }
+    /**
+     * Replay a broker event (reprocess a failed or successful event)
+     *
+     * @example
+     * ```ts
+     * const result = await brokers.replayEvent({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   eventId: 'event-123',
+     *   force: true, // Replay even if already successful
+     * });
+     *
+     * if (result.success) {
+     *   console.log('New event ID:', result.new_event_id);
+     * }
+     * ```
+     */
+    async replayEvent(options) {
+        try {
+            await this.initializeProductForEvents(options.product);
+            return await this.processorApiService.replayBrokerEvent({
+                product: options.product,
+                env: options.env,
+                eventId: options.eventId,
+                force: options.force,
+            }, this.getUserAccess());
+        }
+        catch (error) {
+            if (error instanceof BrokerError)
+                throw error;
+            throw new BrokerError(`Failed to replay broker event: ${error}`, 'REPLAY_EVENT_FAILED', error);
+        }
+    }
+    /**
+     * Get broker event statistics
+     *
+     * @example
+     * ```ts
+     * const stats = await brokers.getEventStats({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   brokerTag: 'order-events',
+     * });
+     *
+     * console.log('Total events:', stats.total_events);
+     * console.log('Failed:', stats.failed_count);
+     * console.log('Success:', stats.success_count);
+     * ```
+     */
+    async getEventStats(options) {
+        try {
+            await this.initializeProductForEvents(options.product);
+            return await this.processorApiService.getBrokerEventStats({
+                product: options.product,
+                env: options.env,
+                brokerTag: options.brokerTag,
+            }, this.getUserAccess());
+        }
+        catch (error) {
+            if (error instanceof BrokerError)
+                throw error;
+            throw new BrokerError(`Failed to get broker event stats: ${error}`, 'GET_EVENT_STATS_FAILED', error);
+        }
+    }
+    /**
+     * Reprocess messages from the Dead Letter Queue
+     *
+     * @example
+     * ```ts
+     * const result = await brokers.reprocessDLQ({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   brokerTag: 'order-events',
+     *   limit: 100,
+     * });
+     *
+     * console.log('Reprocessed:', result.reprocessed_count);
+     * console.log('Failed:', result.failed_count);
+     * ```
+     */
+    async reprocessDLQ(options) {
+        try {
+            await this.initializeProductForEvents(options.product);
+            return await this.processorApiService.reprocessDLQ({
+                product: options.product,
+                env: options.env,
+                brokerTag: options.brokerTag,
+                topicTag: options.topicTag,
+                messageIds: options.messageIds,
+                limit: options.limit,
+            }, this.getUserAccess());
+        }
+        catch (error) {
+            if (error instanceof BrokerError)
+                throw error;
+            throw new BrokerError(`Failed to reprocess DLQ: ${error}`, 'REPROCESS_DLQ_FAILED', error);
+        }
+    }
+    /**
+     * Check if an idempotency key has already been processed
+     *
+     * @example
+     * ```ts
+     * const result = await brokers.checkIdempotency({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   idempotencyKey: 'order-123-payment',
+     * });
+     *
+     * if (result.exists) {
+     *   console.log('Already processed, event ID:', result.event_id);
+     * }
+     * ```
+     */
+    async checkIdempotency(options) {
+        try {
+            await this.initializeProductForEvents(options.product);
+            return await this.processorApiService.checkIdempotency({
+                product: options.product,
+                env: options.env,
+                idempotencyKey: options.idempotencyKey,
+            }, this.getUserAccess());
+        }
+        catch (error) {
+            if (error instanceof BrokerError)
+                throw error;
+            throw new BrokerError(`Failed to check idempotency: ${error}`, 'CHECK_IDEMPOTENCY_FAILED', error);
+        }
+    }
+    /**
+     * Publish a message with idempotency guarantee
+     *
+     * This ensures the message is only processed once, even if published multiple times
+     * with the same idempotency key.
+     *
+     * @example
+     * ```ts
+     * const result = await brokers.publishIdempotent({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   event: 'order-events:new-orders',
+     *   message: { orderId: '123', amount: 99.99 },
+     *   idempotencyKey: 'order-123-created',
+     *   idempotencyTtl: 86400, // 24 hours
+     * });
+     *
+     * if (result.success) {
+     *   console.log('Published with process ID:', result.process_id);
+     * }
+     * ```
+     */
+    async publishIdempotent(options) {
+        try {
+            // Check if already processed
+            const existing = await this.checkIdempotency({
+                product: options.product,
+                env: options.env,
+                idempotencyKey: options.idempotencyKey,
+            });
+            if (existing.exists) {
+                return {
+                    success: true,
+                    process_id: existing.event_id,
+                    error: 'Already processed (idempotent)',
+                };
+            }
+            // Proceed with publish - the message includes idempotency metadata
+            const result = await this.publish(Object.assign(Object.assign({}, options), { message: Object.assign(Object.assign({}, options.message), { __idempotency_key: options.idempotencyKey, __idempotency_ttl: options.idempotencyTtl || 86400 }) }));
+            return result;
+        }
+        catch (error) {
+            if (error instanceof BrokerError)
+                throw error;
+            throw new BrokerError(`Failed to publish with idempotency: ${error}`, 'PUBLISH_IDEMPOTENT_FAILED', error);
+        }
+    }
+}
+exports.BrokersService = BrokersService;
+BrokersService.PUBLISH_SUCCESS_LOG_DEDUPE_MS = 2000;
+exports.default = BrokersService;
+//# sourceMappingURL=brokers.service.js.map