@ductape/sdk 0.1.6 → 0.1.8

package/dist/brokers/brokers.service.d.ts

@@ -1,438 +0,0 @@
-/**
- * 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
- */
-import { IBrokerServiceConfig, IPublishOptions, ISubscribeOptions, IPublishResult, ISubscribeResult, IGetBrokerEventsOptions, IGetBrokerEventsResult, IGetBrokerEventOptions, IBrokerEvent, IReplayEventOptions, IReplayEventResult, IReprocessDLQOptions, IReprocessDLQResult, IBrokerEventStats, IIdempotentPublishOptions } from './types';
-import { IProductMessageBroker, IProductMessageBrokerTopic } from '../types';
-/**
- * Error class for broker operations
- */
-export declare class BrokerError extends Error {
-    code: string;
-    details?: unknown;
-    constructor(message: string, code: string, details?: unknown);
-}
-/**
- * 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);
- *   },
- * });
- * ```
- */
-export declare class BrokersService {
-    private config;
-    private productBuilderService;
-    private processorApiService;
-    private logService;
-    private productId;
-    private productTag;
-    private privateKey;
-    /** Cache manager for 3-tier caching */
-    private cacheManager;
-    /** Private keys per product for cache encryption */
-    private privateKeys;
-    /** Connection pool for broker services - keyed by broker type + config hash */
-    private brokerServicePool;
-    /** When using shared registry, track poolKey -> sharedKey so disconnectAll can remove from shared */
-    private poolKeyToSharedKey;
-    /** Cache for initialized broker configs - keyed by "productTag:brokerTag:envSlug" */
-    private initializedBrokerCache;
-    /** Cache for initialized products - keyed by productTag */
-    private initializedProducts;
-    /** Cache for registered broker consumers - keyed by consumerTag to track which consumers have been registered */
-    private registeredConsumers;
-    /** Local cache for cache configurations to avoid repeated API calls */
-    private cacheConfigCache;
-    /** Dedupe "Publish to broker - success" when same event is published twice in quick succession (e.g. workflow step run twice) */
-    private lastPublishSuccessLogKey;
-    private lastPublishSuccessLogTime;
-    private static readonly PUBLISH_SUCCESS_LOG_DEDUPE_MS;
-    constructor(config: IBrokerServiceConfig);
-    /**
-     * Get user access credentials
-     */
-    private getUserAccess;
-    /**
-     * Initialize product and get broker configuration (with caching)
-     */
-    private initializeBroker;
-    /**
-     * Initialize logging service
-     */
-    private initializeLogService;
-    /**
-     * Validate cache tag exists in product and return cache configuration
-     * Uses local in-memory cache to avoid repeated API calls (5 minute TTL)
-     */
-    private validateCache;
-    /**
-     * Generate a cache key for the broker service pool
-     */
-    private getBrokerPoolKey;
-    /**
-     * 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.
-     */
-    private getBrokerService;
-    /**
-     * Disconnect all pooled broker connections (e.g. at end of workflow run). Safe if pool is empty.
-     */
-    disconnectAll(): Promise<void>;
-    /**
-     * 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.
-     */
-    warmBrokerConnections(options: {
-        product: string;
-        env: string;
-        brokerTags: string[];
-    }): Promise<void>;
-    /**
-     * Auto-register a topic in the background (fire-and-forget)
-     * This is intentionally lightweight - no pre-check, no post-fetch
-     */
-    private ensureTopicRegistered;
-    /**
-     * Auto-register a producer if it doesn't exist
-     */
-    private ensureProducerRegistered;
-    /**
-     * Auto-register a consumer if it doesn't exist
-     */
-    private ensureConsumerRegistered;
-    /**
-     * Publish a message to a broker topic
-     */
-    publish(options: IPublishOptions): Promise<IPublishResult>;
-    /**
-     * Subscribe to a broker topic
-     */
-    subscribe(options: ISubscribeOptions): Promise<ISubscribeResult>;
-    /**
-     * Get all message brokers for a product
-     */
-    getBrokers(productTag: string): Promise<IProductMessageBroker[]>;
-    /**
-     * Get a specific message broker by tag
-     */
-    getBroker(productTag: string, brokerTag: string): Promise<IProductMessageBroker | null>;
-    /**
-     * Get all topics for a message broker
-     */
-    getTopics(productTag: string, brokerTag: string): Promise<IProductMessageBrokerTopic[]>;
-    /**
-     * Get a specific topic by event string (broker_tag:topic_tag)
-     */
-    getTopic(productTag: string, event: string): Promise<IProductMessageBrokerTopic | null>;
-    /**
-     * 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
-     * ```
-     */
-    testConnection(options: {
-        product: string;
-        env: string;
-        broker: string;
-    }): Promise<{
-        connected: boolean;
-        latency?: number;
-        error?: string;
-    }>;
-    /**
-     * Initialize product for event operations (without broker/topic lookup)
-     */
-    private initializeProductForEvents;
-    /**
-     * Encrypt payload data using the product's private key
-     */
-    private encryptPayload;
-    /**
-     * Decrypt payload data using the product's private key
-     */
-    private decryptPayload;
-    /**
-     * 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);
-     * }
-     * ```
-     */
-    getEvents(options: IGetBrokerEventsOptions): Promise<IGetBrokerEventsResult>;
-    /**
-     * 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);
-     * }
-     * ```
-     */
-    getEvent(options: IGetBrokerEventOptions): Promise<IBrokerEvent | null>;
-    /**
-     * 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);
-     * }
-     * ```
-     */
-    replayEvent(options: IReplayEventOptions): Promise<IReplayEventResult>;
-    /**
-     * 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);
-     * ```
-     */
-    getEventStats(options: {
-        product: string;
-        env: string;
-        brokerTag: string;
-    }): Promise<IBrokerEventStats>;
-    /**
-     * 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);
-     * ```
-     */
-    reprocessDLQ(options: IReprocessDLQOptions): Promise<IReprocessDLQResult>;
-    /**
-     * 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);
-     * }
-     * ```
-     */
-    checkIdempotency(options: {
-        product: string;
-        env: string;
-        idempotencyKey: string;
-    }): Promise<{
-        exists: boolean;
-        event_id?: string;
-    }>;
-    /**
-     * 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);
-     * }
-     * ```
-     */
-    publishIdempotent(options: IIdempotentPublishOptions): Promise<IPublishResult>;
-    /**
-     * Messages namespace for workbench broker message queries
-     * All methods decrypt message content before returning
-     */
-    messages: {
-        /**
-         * Query broker messages with filtering and pagination
-         * Decrypts message content before returning
-         */
-        query: (options: {
-            product: string;
-            env: string;
-            brokerTag: string;
-            topicTag?: string;
-            producerTag?: string;
-            consumerTag?: string;
-            status?: string;
-            startDate?: string;
-            endDate?: string;
-            page?: number;
-            limit?: number;
-        }) => Promise<{
-            messages: any[];
-            total: number;
-            page: number;
-            limit: number;
-            hasMore: boolean;
-        }>;
-        /**
-         * Get broker producers with pagination
-         */
-        getProducers: (options: {
-            product: string;
-            env: string;
-            brokerTag: string;
-            topicTag?: string;
-            page?: number;
-            limit?: number;
-        }) => Promise<{
-            producers: any[];
-            total: number;
-            page: number;
-            limit: number;
-            hasMore: boolean;
-        }>;
-        /**
-         * Get broker consumers with pagination
-         */
-        getConsumers: (options: {
-            product: string;
-            env: string;
-            brokerTag: string;
-            topicTag?: string;
-            page?: number;
-            limit?: number;
-        }) => Promise<{
-            consumers: any[];
-            total: number;
-            page: number;
-            limit: number;
-            hasMore: boolean;
-        }>;
-        /**
-         * Get broker dead letters with pagination
-         * Decrypts message content before returning
-         */
-        getDeadLetters: (options: {
-            product: string;
-            env: string;
-            brokerTag: string;
-            topicTag?: string;
-            consumerTag?: string;
-            startDate?: string;
-            endDate?: string;
-            page?: number;
-            limit?: number;
-        }) => Promise<{
-            deadLetters: any[];
-            total: number;
-            page: number;
-            limit: number;
-            hasMore: boolean;
-        }>;
-        /**
-         * Get comprehensive broker message statistics
-         */
-        getStats: (options: {
-            product: string;
-            env: string;
-            brokerTag: string;
-        }) => Promise<any>;
-        /**
-         * Get broker dashboard overview data
-         * Decrypts message content for recent messages
-         */
-        getDashboard: (options: {
-            product: string;
-            env: string;
-            brokerTag: string;
-        }) => Promise<any>;
-    };
-}
-export default BrokersService;