@ductape/sdk 0.0.4-v9 → 0.0.4-v91

package/dist/brokers/brokers.service.js

@@ -0,0 +1,797 @@
+"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");
+/**
+ * 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) {
+        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();
+        this.config = config;
+        this.productBuilderService = 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,
+        });
+        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,
+        };
+    }
+    /**
+     * Initialize product and get broker configuration
+     */
+    async initializeBroker(productTag, envSlug, event) {
+        // Parse event to get broker and topic tags
+        const { brokerTag, topicTag } = (0, broker_util_1.parseEventString)(event);
+        // Initialize product
+        await this.productBuilderService.initializeProductByTag(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');
+        }
+        // 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');
+        }
+        // Fetch topic configuration
+        const topic = await this.productBuilderService.fetchMessageBrokerTopic(event);
+        if (!topic) {
+            throw new BrokerError(`Topic ${topicTag} not found in broker ${brokerTag}`, 'TOPIC_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: envSlug });
+                resolvedConfig = resolved.value;
+            }
+            else {
+                throw new BrokerError(`Broker configuration contains secret references but secrets service is not initialized. ` +
+                    `Please ensure the Ductape client is properly initialized.`, 'SECRETS_NOT_INITIALIZED');
+            }
+        }
+        // Create a new brokerEnv object with resolved config
+        const resolvedBrokerEnv = Object.assign(Object.assign({}, brokerEnv), { config: resolvedConfig });
+        // Determine the topic URL/name
+        let topicUrl = topic.name;
+        // Special handling for AWS SQS which requires queue URLs
+        if (brokerEnv.type === types_1.MessageBrokerTypes.AWS_SQS) {
+            topicUrl = (0, broker_util_1.getSqsQueueUrl)(topic, envSlug);
+        }
+        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,
+            });
+        }
+    }
+    /**
+     * Validate cache tag exists in product and return cache configuration
+     */
+    async validateCache(cacheTag) {
+        const cache = await this.productBuilderService.fetchCache(cacheTag);
+        if (!cache) {
+            throw new BrokerError(`Cache configuration '${cacheTag}' does not exist`, 'CACHE_NOT_FOUND');
+        }
+        return { expiry: cache.expiry };
+    }
+    /**
+     * Get or create broker service instance
+     */
+    async getBrokerService(type, config) {
+        if ((0, broker_util_1.isBrowser)()) {
+            throw new BrokerError('Broker operations are not supported in browser environment', 'BROWSER_NOT_SUPPORTED');
+        }
+        const createBrokerService = await (0, broker_util_1.loadBrokerService)();
+        if (!createBrokerService) {
+            throw new BrokerError('Failed to load broker service', 'BROKER_SERVICE_LOAD_FAILED');
+        }
+        return createBrokerService(type, config);
+    }
+    /**
+     * 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;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        const start = Date.now();
+        const { cache } = options;
+        let sessionLogFields = {};
+        let resolvedMessage = options.message;
+        try {
+            const { broker, topic, brokerEnv, topicUrl } = await this.initializeBroker(options.product, options.env, options.event);
+            const { brokerTag, topicTag } = (0, broker_util_1.parseEventString)(options.event);
+            // 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);
+                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.MESSAGEBROKER, 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 } }));
+                    this.logService.publish();
+                    return cached.data;
+                }
+            }
+            // Get broker service and publish
+            const brokerService = await this.getBrokerService(brokerEnv.type, brokerEnv.config);
+            await brokerService.publish(topicUrl, resolvedMessage);
+            const result = {
+                success: true,
+                process_id,
+            };
+            // Store in cache for idempotency
+            if (cache && this.cacheManager && this.privateKey) {
+                const cacheConfig = await this.validateCache(cache);
+                await 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();
+            this.logService.add(Object.assign(Object.assign({}, baseLogs), { start,
+                end, message: 'Publish to broker - success', successful_execution: true, status: types_2.LogEventStatus.SUCCESS }));
+            this.logService.publish();
+            return result;
+        }
+        catch (error) {
+            const end = Date.now();
+            this.initializeLogService();
+            (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add(Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id,
+                start,
+                end, type: types_2.LogEventTypes.MESSAGEBROKER, message: 'Publish to broker - failed', failed_execution: true, data: { event: options.event, error: String(error) }, status: types_2.LogEventStatus.FAIL }, sessionLogFields));
+            await ((_b = this.logService) === null || _b === void 0 ? void 0 : _b.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;
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        const start = Date.now();
+        try {
+            const { broker, topic, brokerEnv, topicUrl } = await this.initializeBroker(options.product, options.env, options.event);
+            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.MESSAGEBROKER,
+                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
+            const brokerService = await this.getBrokerService(brokerEnv.type, brokerEnv.config);
+            await brokerService.subscribe(topicUrl, options.callback);
+            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();
+            (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add({
+                product_tag: options.product,
+                workspace_id: this.config.workspace_id,
+                env: options.env,
+                process_id,
+                start,
+                end,
+                type: types_2.LogEventTypes.MESSAGEBROKER,
+                message: 'Subscribe to broker - failed',
+                failed_execution: true,
+                data: { event: options.event, error: String(error) },
+                status: types_2.LogEventStatus.FAIL,
+            });
+            await ((_b = this.logService) === null || _b === void 0 ? void 0 : _b.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) {
+        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);
+            // 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;
+exports.default = BrokersService;
+//# sourceMappingURL=brokers.service.js.map