@ductape/sdk 0.1.7 → 0.1.8

package/dist/brokers/brokers.service.js

@@ -1,1294 +0,0 @@
-"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 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 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: envSlug });
-                resolvedConfig = resolved.value;
-            }
-            else {
-                throw new BrokerError(`Broker configuration contains secret references but secrets service is not initialized.`, 'SECRETS_NOT_INITIALIZED');
-            }
-        }
-        // 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