@ductape/sdk 0.0.4-v51 → 0.0.4-v53

package/dist/brokers/index.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Ductape Brokers Module
+ *
+ * Provides a unified API for message broker operations across
+ * RabbitMQ, Kafka, AWS SQS, Redis, and Google Pub/Sub.
+ *
+ * @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);
+ *   },
+ * });
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSqsQueueUrl = exports.isValidSqsUrl = exports.parseEventString = exports.loadBrokerService = exports.GooglePubSubService = exports.RedisService = exports.SQSService = exports.KafkaService = exports.RabbitMQService = exports.BrokersServiceDefault = exports.BrokerError = exports.BrokersService = void 0;
+// Main service
+var brokers_service_1 = require("./brokers.service");
+Object.defineProperty(exports, "BrokersService", { enumerable: true, get: function () { return brokers_service_1.BrokersService; } });
+Object.defineProperty(exports, "BrokerError", { enumerable: true, get: function () { return brokers_service_1.BrokerError; } });
+var brokers_service_2 = require("./brokers.service");
+Object.defineProperty(exports, "BrokersServiceDefault", { enumerable: true, get: function () { return __importDefault(brokers_service_2).default; } });
+// Types
+__exportStar(require("./types"), exports);
+// Provider services (for advanced use cases)
+var rabbitmq_service_1 = require("./utils/providers/rabbitmq.service");
+Object.defineProperty(exports, "RabbitMQService", { enumerable: true, get: function () { return rabbitmq_service_1.RabbitMQService; } });
+var kafka_service_1 = require("./utils/providers/kafka.service");
+Object.defineProperty(exports, "KafkaService", { enumerable: true, get: function () { return kafka_service_1.KafkaService; } });
+var aws_sqs_service_1 = require("./utils/providers/aws-sqs.service");
+Object.defineProperty(exports, "SQSService", { enumerable: true, get: function () { return aws_sqs_service_1.SQSService; } });
+var redis_service_1 = require("./utils/providers/redis.service");
+Object.defineProperty(exports, "RedisService", { enumerable: true, get: function () { return redis_service_1.RedisService; } });
+var google_pubsub_service_1 = require("./utils/providers/google-pubsub.service");
+Object.defineProperty(exports, "GooglePubSubService", { enumerable: true, get: function () { return google_pubsub_service_1.GooglePubSubService; } });
+// Utilities
+var broker_util_1 = require("./utils/broker.util");
+Object.defineProperty(exports, "loadBrokerService", { enumerable: true, get: function () { return broker_util_1.loadBrokerService; } });
+Object.defineProperty(exports, "parseEventString", { enumerable: true, get: function () { return broker_util_1.parseEventString; } });
+Object.defineProperty(exports, "isValidSqsUrl", { enumerable: true, get: function () { return broker_util_1.isValidSqsUrl; } });
+Object.defineProperty(exports, "getSqsQueueUrl", { enumerable: true, get: function () { return broker_util_1.getSqsQueueUrl; } });
+//# sourceMappingURL=index.js.map

package/dist/brokers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/brokers/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;;;;;;;;;;;;;;;;;;;;AAEH,eAAe;AACf,qDAAgE;AAAvD,iHAAA,cAAc,OAAA;AAAE,8GAAA,WAAW,OAAA;AACpC,qDAAqE;AAA5D,yIAAA,OAAO,OAAyB;AAEzC,QAAQ;AACR,0CAAwB;AAExB,6CAA6C;AAC7C,uEAAqE;AAA5D,mHAAA,eAAe,OAAA;AACxB,iEAA+D;AAAtD,6GAAA,YAAY,OAAA;AACrB,qEAA+D;AAAtD,6GAAA,UAAU,OAAA;AACnB,iEAA+D;AAAtD,6GAAA,YAAY,OAAA;AACrB,iFAA8E;AAArE,4HAAA,mBAAmB,OAAA;AAE5B,YAAY;AACZ,mDAAyG;AAAhG,gHAAA,iBAAiB,OAAA;AAAE,+GAAA,gBAAgB,OAAA;AAAE,4GAAA,aAAa,OAAA;AAAE,6GAAA,cAAc,OAAA"}

package/dist/brokers/types/index.d.ts

@@ -0,0 +1,288 @@
+/**
+ * Broker Types
+ *
+ * Type definitions for message broker operations
+ */
+import { MessageBrokerTypes } from '../../types';
+export { IProductMessageBroker, IProductMessageBrokerTopic, IMessageBrokerEnvs, IPublishRequest, ISubscribeRequest, IMessageBrokerPublishInput, IMessageBrokerSubscribeInput, } from '../../types';
+/**
+ * Configuration for broker service initialization
+ */
+export interface IBrokerServiceConfig {
+    workspace_id: string;
+    public_key: string;
+    user_id: string;
+    token: string;
+    env_type?: string;
+}
+/**
+ * Options for publishing a message to a broker topic
+ */
+export interface IPublishOptions {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Event in format broker_tag:topic_tag */
+    event: string;
+    /** Message payload to publish */
+    message: Record<string, unknown>;
+    /** Optional cache key */
+    cache?: string;
+    /** Optional session info */
+    session?: {
+        tag: string;
+        token: string;
+    };
+}
+/**
+ * Options for subscribing to a broker topic
+ */
+export interface ISubscribeOptions {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Event in format broker_tag:topic_tag */
+    event: string;
+    /** Callback function invoked when a message is received */
+    callback: (message: object) => Promise<void>;
+}
+/**
+ * Result of a publish operation
+ */
+export interface IPublishResult {
+    success: boolean;
+    process_id?: string;
+    error?: string;
+}
+/**
+ * Result of a subscribe operation
+ */
+export interface ISubscribeResult {
+    success: boolean;
+    process_id?: string;
+    error?: string;
+}
+export { RedisConfig, GooglePubSubConfig, RabbitMQConfig, KafkaConfig, AWSSQSConfig, NatsConfig, } from '../../types';
+/**
+ * Union type for all broker configurations
+ * Uses the existing config types from productsBuilder.types
+ */
+export type BrokerConfig = import('../../types').RedisConfig | import('../../types').GooglePubSubConfig | import('../../types').RabbitMQConfig | import('../../types').KafkaConfig | import('../../types').AWSSQSConfig | import('../../types').NatsConfig;
+/**
+ * Interface for message broker service implementations
+ */
+export interface IMessageBrokerService {
+    connect(): Promise<void>;
+    publish(topic: string, message: object): Promise<void>;
+    subscribe(topic: string, callback: (message: object) => Promise<void>): Promise<void>;
+    disconnect(): Promise<void>;
+}
+/**
+ * Bootstrap data structure for broker operations
+ */
+export interface IBrokerBootstrapData {
+    broker: {
+        tag: string;
+        name: string;
+        envs: Array<{
+            slug: string;
+            type: MessageBrokerTypes;
+            config: BrokerConfig;
+        }>;
+    };
+    topic: {
+        name: string;
+        tag: string;
+        queueUrls?: Array<{
+            env_slug: string;
+            url: string;
+        }>;
+    };
+    env: {
+        slug: string;
+        active: boolean;
+    };
+}
+/**
+ * Options for dispatching broker operations via bootstrap
+ */
+export interface IBrokerDispatchOptions {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Event in format broker_tag:topic_tag */
+    event: string;
+    /** Message payload (for publish) */
+    message?: Record<string, unknown>;
+    /** Callback function (for subscribe) */
+    callback?: (message: object) => Promise<void>;
+    /** Optional cache key */
+    cache?: string;
+    /** Optional session info */
+    session?: {
+        tag: string;
+        token: string;
+    };
+}
+/**
+ * Broker event categories
+ */
+export type BrokerEventCategory = 'consumer' | 'producer' | 'dead-letter' | 'message' | 'error';
+/**
+ * Broker event status
+ */
+export type BrokerEventStatus = 'success' | 'failed' | 'pending' | 'duplicate' | 'retrying';
+/**
+ * Broker event metadata
+ */
+export interface IBrokerEventMetadata {
+    consumer_id?: string;
+    producer_id?: string;
+    error_message?: string;
+    retry_count?: number;
+    message_id?: string;
+    idempotency_key?: string;
+    partition?: number;
+    offset?: number;
+}
+/**
+ * Broker event record
+ */
+export interface IBrokerEvent {
+    id: string;
+    event_type: string;
+    category: BrokerEventCategory;
+    topic: string;
+    broker_tag: string;
+    message: string;
+    timestamp: Date;
+    status: BrokerEventStatus;
+    idempotent: boolean;
+    request_data?: Record<string, unknown>;
+    response_data?: Record<string, unknown>;
+    metadata?: IBrokerEventMetadata;
+    product_tag: string;
+    env: string;
+    process_id?: string;
+}
+/**
+ * Options for fetching broker events
+ */
+export interface IGetBrokerEventsOptions {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Broker tag */
+    brokerTag: string;
+    /** Filter by topic */
+    topic?: string;
+    /** Filter by category */
+    category?: BrokerEventCategory;
+    /** Filter by status */
+    status?: BrokerEventStatus;
+    /** Filter by idempotent flag */
+    idempotent?: boolean;
+    /** Start date for filtering */
+    startDate?: Date;
+    /** End date for filtering */
+    endDate?: Date;
+    /** Page number */
+    page?: number;
+    /** Items per page */
+    limit?: number;
+}
+/**
+ * Result of fetching broker events
+ */
+export interface IGetBrokerEventsResult {
+    events: IBrokerEvent[];
+    total: number;
+    page: number;
+    limit: number;
+    hasMore: boolean;
+}
+/**
+ * Options for getting a single broker event
+ */
+export interface IGetBrokerEventOptions {
+    /** Product tag */
+    product: string;
+    /** Event ID */
+    eventId: string;
+}
+/**
+ * Options for replaying/reprocessing a broker event
+ */
+export interface IReplayEventOptions {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Event ID to replay */
+    eventId: string;
+    /** Force replay even if already successful */
+    force?: boolean;
+}
+/**
+ * Result of replaying a broker event
+ */
+export interface IReplayEventResult {
+    success: boolean;
+    new_event_id?: string;
+    process_id?: string;
+    error?: string;
+}
+/**
+ * Options for publishing with idempotency
+ */
+export interface IIdempotentPublishOptions extends IPublishOptions {
+    /** Unique idempotency key to prevent duplicate processing */
+    idempotencyKey: string;
+    /** TTL for idempotency check in seconds (default: 86400 = 24 hours) */
+    idempotencyTtl?: number;
+}
+/**
+ * Options for reprocessing dead letter queue messages
+ */
+export interface IReprocessDLQOptions {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Broker tag */
+    brokerTag: string;
+    /** Topic tag */
+    topicTag?: string;
+    /** Specific message IDs to reprocess (if empty, reprocess all) */
+    messageIds?: string[];
+    /** Maximum number of messages to reprocess */
+    limit?: number;
+}
+/**
+ * Result of reprocessing dead letter queue
+ */
+export interface IReprocessDLQResult {
+    success: boolean;
+    reprocessed_count: number;
+    failed_count: number;
+    event_ids: string[];
+    errors?: string[];
+}
+/**
+ * Broker event statistics
+ */
+export interface IBrokerEventStats {
+    total_events: number;
+    success_count: number;
+    failed_count: number;
+    pending_count: number;
+    duplicate_count: number;
+    dead_letter_count: number;
+    idempotent_count: number;
+    events_by_topic: Record<string, number>;
+    events_by_category: Record<BrokerEventCategory, number>;
+}

package/dist/brokers/types/index.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Broker Types
+ *
+ * Type definitions for message broker operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/brokers/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/brokers/types/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG"}

package/dist/brokers/utils/broker.util.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Broker utility functions for message broker operations
+ */
+import { MessageBrokerTypes } from '../../types';
+import { IMessageBrokerService, BrokerConfig } from '../types';
+/**
+ * Check if running in browser environment
+ */
+export declare function isBrowser(): boolean;
+/**
+ * Validate SQS Queue URL format
+ */
+export declare function isValidSqsUrl(url: string): boolean;
+/**
+ * Dynamic import for broker services to support tree-shaking
+ */
+export declare function loadBrokerService(): Promise<((type: MessageBrokerTypes, config: BrokerConfig) => IMessageBrokerService) | null>;
+/**
+ * Parse event string to get broker tag and topic tag
+ */
+export declare function parseEventString(event: string): {
+    brokerTag: string;
+    topicTag: string;
+};
+/**
+ * Get queue URL for AWS SQS based on environment
+ */
+export declare function getSqsQueueUrl(topic: {
+    queueUrls?: Array<{
+        env_slug: string;
+        url: string;
+    }>;
+}, envSlug: string): string;

package/dist/brokers/utils/broker.util.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * Broker utility functions for message broker operations
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBrowser = isBrowser;
+exports.isValidSqsUrl = isValidSqsUrl;
+exports.loadBrokerService = loadBrokerService;
+exports.parseEventString = parseEventString;
+exports.getSqsQueueUrl = getSqsQueueUrl;
+const types_1 = require("../../types");
+/**
+ * Check if running in browser environment
+ */
+function isBrowser() {
+    return typeof window !== 'undefined';
+}
+/**
+ * Validate SQS Queue URL format
+ */
+function isValidSqsUrl(url) {
+    const sqsUrlPattern = /^https:\/\/sqs\.[a-z0-9-]+\.amazonaws\.com\/\d+\/[\w-]+$/;
+    return sqsUrlPattern.test(url);
+}
+/**
+ * Dynamic import for broker services to support tree-shaking
+ */
+async function loadBrokerService() {
+    if (isBrowser()) {
+        return null;
+    }
+    try {
+        // Dynamically import broker services
+        const [{ RabbitMQService }, { KafkaService }, { SQSService }, { RedisService }, { GooglePubSubService }, { NatsService },] = await Promise.all([
+            Promise.resolve().then(() => __importStar(require('./providers/rabbitmq.service'))),
+            Promise.resolve().then(() => __importStar(require('./providers/kafka.service'))),
+            Promise.resolve().then(() => __importStar(require('./providers/aws-sqs.service'))),
+            Promise.resolve().then(() => __importStar(require('./providers/redis.service'))),
+            Promise.resolve().then(() => __importStar(require('./providers/google-pubsub.service'))),
+            Promise.resolve().then(() => __importStar(require('./providers/nats.service'))),
+        ]);
+        return (type, config) => {
+            switch (type) {
+                case types_1.MessageBrokerTypes.RABBITMQ:
+                    return new RabbitMQService(config);
+                case types_1.MessageBrokerTypes.KAFKA:
+                    return new KafkaService(config);
+                case types_1.MessageBrokerTypes.AWS_SQS:
+                    return new SQSService(config);
+                case types_1.MessageBrokerTypes.REDIS:
+                    return new RedisService(config);
+                case types_1.MessageBrokerTypes.GOOGLE_PUBSUB:
+                    return new GooglePubSubService(config);
+                case types_1.MessageBrokerTypes.NATS:
+                    return new NatsService(config);
+                default:
+                    throw new Error(`Unsupported broker type: ${type}`);
+            }
+        };
+    }
+    catch (error) {
+        console.warn('Failed to load broker services:', error);
+        return null;
+    }
+}
+/**
+ * Parse event string to get broker tag and topic tag
+ */
+function parseEventString(event) {
+    const [brokerTag, topicTag] = event.split(':');
+    if (!brokerTag || !topicTag) {
+        throw new Error(`Message broker events should be in the format broker_tag:topic_tag. Received: ${event}`);
+    }
+    return { brokerTag, topicTag };
+}
+/**
+ * Get queue URL for AWS SQS based on environment
+ */
+function getSqsQueueUrl(topic, envSlug) {
+    if (!topic.queueUrls || topic.queueUrls.length === 0) {
+        throw new Error(`AWS SQS topic requires queue URLs to be defined`);
+    }
+    const queueUrl = topic.queueUrls.find((el) => el.env_slug === envSlug);
+    if (!queueUrl) {
+        throw new Error(`AWS SQS queue URL not found for environment ${envSlug}`);
+    }
+    if (!isValidSqsUrl(queueUrl.url)) {
+        throw new Error('AWS SQS queueUrl must be in format "https://sqs.<region>.amazonaws.com/<account-id>/<queue-name>"');
+    }
+    return queueUrl.url;
+}
+//# sourceMappingURL=broker.util.js.map

package/dist/brokers/utils/broker.util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"broker.util.js","sourceRoot":"","sources":["../../../src/brokers/utils/broker.util.ts"],"names":[],"mappings":";AAAA;;GAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQH,8BAEC;AAKD,sCAGC;AAKD,8CA+CC;AAKD,4CAQC;AAKD,wCAqBC;AA3GD,uCAAiD;AAGjD;;GAEG;AACH,SAAgB,SAAS;IACvB,OAAO,OAAO,MAAM,KAAK,WAAW,CAAC;AACvC,CAAC;AAED;;GAEG;AACH,SAAgB,aAAa,CAAC,GAAW;IACvC,MAAM,aAAa,GAAG,0DAA0D,CAAC;IACjF,OAAO,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACjC,CAAC;AAED;;GAEG;AACI,KAAK,UAAU,iBAAiB;IAGrC,IAAI,SAAS,EAAE,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,CAAC;QACH,qCAAqC;QACrC,MAAM,CACJ,EAAE,eAAe,EAAE,EACnB,EAAE,YAAY,EAAE,EAChB,EAAE,UAAU,EAAE,EACd,EAAE,YAAY,EAAE,EAChB,EAAE,mBAAmB,EAAE,EACvB,EAAE,WAAW,EAAE,EAChB,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;8DACb,8BAA8B;8DAC9B,2BAA2B;8DAC3B,6BAA6B;8DAC7B,2BAA2B;8DAC3B,mCAAmC;8DACnC,0BAA0B;SAClC,CAAC,CAAC;QAEH,OAAO,CAAC,IAAwB,EAAE,MAAoB,EAAyB,EAAE;YAC/E,QAAQ,IAAI,EAAE,CAAC;gBACb,KAAK,0BAAkB,CAAC,QAAQ;oBAC9B,OAAO,IAAI,eAAe,CAAC,MAAa,CAAC,CAAC;gBAC5C,KAAK,0BAAkB,CAAC,KAAK;oBAC3B,OAAO,IAAI,YAAY,CAAC,MAAa,CAAC,CAAC;gBACzC,KAAK,0BAAkB,CAAC,OAAO;oBAC7B,OAAO,IAAI,UAAU,CAAC,MAAa,CAAC,CAAC;gBACvC,KAAK,0BAAkB,CAAC,KAAK;oBAC3B,OAAO,IAAI,YAAY,CAAC,MAAa,CAAC,CAAC;gBACzC,KAAK,0BAAkB,CAAC,aAAa;oBACnC,OAAO,IAAI,mBAAmB,CAAC,MAAa,CAAC,CAAC;gBAChD,KAAK,0BAAkB,CAAC,IAAI;oBAC1B,OAAO,IAAI,WAAW,CAAC,MAAa,CAAC,CAAC;gBACxC;oBACE,MAAM,IAAI,KAAK,CAAC,4BAA4B,IAAI,EAAE,CAAC,CAAC;YACxD,CAAC;QACH,CAAC,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,IAAI,CAAC,iCAAiC,EAAE,KAAK,CAAC,CAAC;QACvD,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAgB,gBAAgB,CAAC,KAAa;IAC5C,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAE/C,IAAI,CAAC,SAAS,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,iFAAiF,KAAK,EAAE,CAAC,CAAC;IAC5G,CAAC;IAED,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC;AACjC,CAAC;AAED;;GAEG;AACH,SAAgB,cAAc,CAC5B,KAA+D,EAC/D,OAAe;IAEf,IAAI,CAAC,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACrD,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;IACrE,CAAC;IAED,MAAM,QAAQ,GAAG,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC;IAEvE,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,+CAA+C,OAAO,EAAE,CAAC,CAAC;IAC5E,CAAC;IAED,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CACb,mGAAmG,CACpG,CAAC;IACJ,CAAC;IAED,OAAO,QAAQ,CAAC,GAAG,CAAC;AACtB,CAAC"}

package/dist/brokers/utils/providers/aws-sqs.service.d.ts

@@ -0,0 +1,16 @@
+import { IMessageBrokerService } from '../../types';
+export declare class SQSService implements IMessageBrokerService {
+    private config;
+    private sqs;
+    private isPolling;
+    constructor(config: {
+        region: string;
+        accessKeyId: string;
+        secretAccessKey: string;
+        queueUrl?: string;
+    });
+    connect(): Promise<void>;
+    publish(topic: string, message: object): Promise<void>;
+    subscribe(queueUrl: string, callback: (message: object) => Promise<void>): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/dist/brokers/utils/providers/aws-sqs.service.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQSService = void 0;
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+class SQSService {
+    constructor(config) {
+        this.config = config;
+        this.isPolling = false;
+        this.sqs = new client_sqs_1.SQSClient({
+            region: config.region,
+            credentials: {
+                accessKeyId: config.accessKeyId,
+                secretAccessKey: config.secretAccessKey,
+            },
+        });
+    }
+    async connect() {
+        // SQS doesn't require explicit connection
+    }
+    async publish(topic, message) {
+        const command = new client_sqs_1.SendMessageCommand({
+            QueueUrl: topic,
+            MessageBody: JSON.stringify(message),
+        });
+        await this.sqs.send(command);
+    }
+    async subscribe(queueUrl, callback) {
+        this.isPolling = true;
+        const pollMessages = async () => {
+            while (this.isPolling) {
+                try {
+                    const command = new client_sqs_1.ReceiveMessageCommand({
+                        QueueUrl: queueUrl,
+                        MaxNumberOfMessages: 10,
+                        WaitTimeSeconds: 20,
+                        VisibilityTimeout: 30,
+                    });
+                    const response = await this.sqs.send(command);
+                    if (response.Messages && response.Messages.length > 0) {
+                        for (const message of response.Messages) {
+                            try {
+                                if (message.Body) {
+                                    await callback(JSON.parse(message.Body));
+                                }
+                                await this.sqs.send(new client_sqs_1.DeleteMessageCommand({
+                                    QueueUrl: queueUrl,
+                                    ReceiptHandle: message.ReceiptHandle,
+                                }));
+                            }
+                            catch (processingError) {
+                                console.error('Error processing SQS message:', processingError);
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    console.error('Error receiving SQS messages:', err);
+                    // Wait before retrying on error
+                    await new Promise((resolve) => setTimeout(resolve, 5000));
+                }
+            }
+        };
+        // Start polling in background
+        pollMessages();
+    }
+    async disconnect() {
+        this.isPolling = false;
+    }
+}
+exports.SQSService = SQSService;
+//# sourceMappingURL=aws-sqs.service.js.map

package/dist/brokers/utils/providers/aws-sqs.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aws-sqs.service.js","sourceRoot":"","sources":["../../../../src/brokers/utils/providers/aws-sqs.service.ts"],"names":[],"mappings":";;;AAAA,oDAAiH;AAGjH,MAAa,UAAU;IAIrB,YACU,MAA2F;QAA3F,WAAM,GAAN,MAAM,CAAqF;QAH7F,cAAS,GAAG,KAAK,CAAC;QAKxB,IAAI,CAAC,GAAG,GAAG,IAAI,sBAAS,CAAC;YACvB,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,WAAW,EAAE;gBACX,WAAW,EAAE,MAAM,CAAC,WAAW;gBAC/B,eAAe,EAAE,MAAM,CAAC,eAAe;aACxC;SACF,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,OAAO;QACX,0CAA0C;IAC5C,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,KAAa,EAAE,OAAe;QAC1C,MAAM,OAAO,GAAG,IAAI,+BAAkB,CAAC;YACrC,QAAQ,EAAE,KAAK;YACf,WAAW,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;SACrC,CAAC,CAAC;QAEH,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC/B,CAAC;IAED,KAAK,CAAC,SAAS,CACb,QAAgB,EAChB,QAA4C;QAE5C,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QAEtB,MAAM,YAAY,GAAG,KAAK,IAAI,EAAE;YAC9B,OAAO,IAAI,CAAC,SAAS,EAAE,CAAC;gBACtB,IAAI,CAAC;oBACH,MAAM,OAAO,GAAG,IAAI,kCAAqB,CAAC;wBACxC,QAAQ,EAAE,QAAQ;wBAClB,mBAAmB,EAAE,EAAE;wBACvB,eAAe,EAAE,EAAE;wBACnB,iBAAiB,EAAE,EAAE;qBACtB,CAAC,CAAC;oBAEH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;oBAE9C,IAAI,QAAQ,CAAC,QAAQ,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;wBACtD,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC;4BACxC,IAAI,CAAC;gCACH,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;oCACjB,MAAM,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;gCAC3C,CAAC;gCAED,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,CACjB,IAAI,iCAAoB,CAAC;oCACvB,QAAQ,EAAE,QAAQ;oCAClB,aAAa,EAAE,OAAO,CAAC,aAAc;iCACtC,CAAC,CACH,CAAC;4BACJ,CAAC;4BAAC,OAAO,eAAe,EAAE,CAAC;gCACzB,OAAO,CAAC,KAAK,CAAC,+BAA+B,EAAE,eAAe,CAAC,CAAC;4BAClE,CAAC;wBACH,CAAC;oBACH,CAAC;gBACH,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,OAAO,CAAC,KAAK,CAAC,+BAA+B,EAAE,GAAG,CAAC,CAAC;oBACpD,gCAAgC;oBAChC,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;gBAC5D,CAAC;YACH,CAAC;QACH,CAAC,CAAC;QAEF,8BAA8B;QAC9B,YAAY,EAAE,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,UAAU;QACd,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACzB,CAAC;CACF;AAhFD,gCAgFC"}

package/dist/brokers/utils/providers/google-pubsub.service.d.ts

@@ -0,0 +1,16 @@
+import { IMessageBrokerService } from '../../types';
+export declare class GooglePubSubService implements IMessageBrokerService {
+    private config;
+    private pubSubClient;
+    constructor(config: {
+        projectId: string;
+        credentials: {
+            client_email: string;
+            private_key: string;
+        };
+    });
+    connect(): Promise<void>;
+    publish(topic: string, message: object): Promise<void>;
+    subscribe(subscriptionName: string, callback: (message: object) => Promise<void>): Promise<void>;
+    disconnect(): Promise<void>;
+}