@motiadev/adapter-rabbitmq-events 0.8.2-beta.140-709523

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## [0.1.0] - 2025-10-22
+
+### Added
+- Initial release of RabbitMQ event adapter for Motia
+- Support for distributed event handling across multiple instances
+- Topic-based message routing with configurable exchange types
+- Durable queues for message persistence
+- Automatic reconnection on connection failures
+- Message acknowledgment for reliability
+- Configurable prefetch for load balancing
+- Full TypeScript support with type definitions
+- Comprehensive documentation and examples
+

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Motia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -0,0 +1,104 @@
+# @motiadev/adapter-rabbitmq-events
+
+RabbitMQ event adapter for Motia framework, enabling distributed event handling across multiple instances.
+
+## Installation
+
+```bash
+npm install @motiadev/adapter-rabbitmq-events
+```
+
+## Usage
+
+Configure the RabbitMQ adapter in your `motia.config.ts`:
+
+```typescript
+import { config } from '@motiadev/core'
+import { RabbitMQEventAdapter } from '@motiadev/adapter-rabbitmq-events'
+
+export default config({
+  adapters: {
+    events: new RabbitMQEventAdapter({
+      url: process.env.RABBITMQ_URL || 'amqp://localhost',
+      exchangeName: 'motia.events',
+      exchangeType: 'topic',
+      durable: true,
+    }),
+  },
+})
+```
+
+## Configuration Options
+
+### RabbitMQEventAdapterConfig
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `url` | `string` | Required | RabbitMQ connection URL (e.g., `amqp://localhost`) |
+| `exchangeName` | `string` | Required | Name of the exchange to use |
+| `exchangeType` | `'direct' \| 'topic' \| 'fanout' \| 'headers'` | Required | Type of exchange |
+| `durable` | `boolean` | `true` | Whether the exchange should survive broker restarts |
+| `autoDelete` | `boolean` | `false` | Whether to delete the exchange when all queues are unbound |
+| `connectionTimeout` | `number` | `10000` | Connection timeout in milliseconds |
+| `reconnectDelay` | `number` | `5000` | Delay before attempting reconnection in milliseconds |
+| `prefetch` | `number` | `10` | Number of messages to prefetch |
+
+## Features
+
+- **Topic-based Routing**: Flexible event routing using RabbitMQ exchanges
+- **Durable Messaging**: Messages persist across broker restarts
+- **Automatic Reconnection**: Handles connection failures gracefully
+- **Message Acknowledgment**: Ensures reliable message delivery
+- **Load Balancing**: Distributes events across multiple instances
+- **Dead Letter Queues**: Failed messages are properly handled
+
+## Example
+
+```typescript
+import { RabbitMQEventAdapter } from '@motiadev/adapter-rabbitmq-events'
+
+const adapter = new RabbitMQEventAdapter({
+  url: 'amqp://user:password@rabbitmq.example.com:5672',
+  exchangeName: 'motia.events',
+  exchangeType: 'topic',
+  durable: true,
+  prefetch: 20,
+})
+```
+
+## Environment Variables
+
+```bash
+RABBITMQ_URL=amqp://localhost:5672
+RABBITMQ_EXCHANGE=motia.events
+```
+
+## Performance Considerations
+
+- Use topic exchanges for flexible routing patterns
+- Set appropriate prefetch values based on your workload
+- Enable message persistence for critical events
+- Monitor queue depths to detect processing bottlenecks
+
+## Troubleshooting
+
+### Connection Issues
+
+If you experience connection problems:
+1. Verify RabbitMQ is running and accessible
+2. Check your connection URL and credentials
+3. Ensure firewall rules allow connections on port 5672
+4. Review RabbitMQ logs for errors
+
+### Message Delivery
+
+If messages are not being delivered:
+1. Verify exchange and queue bindings
+2. Check message acknowledgment settings
+3. Review consumer prefetch settings
+4. Monitor dead letter queues for failed messages
+
+## License
+
+MIT
+

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { RabbitMQEventAdapter } from './rabbitmq-event-adapter';
+export type { RabbitMQEventAdapterConfig, RabbitMQSubscribeOptions } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAC/D,YAAY,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMQEventAdapter = void 0;
+var rabbitmq_event_adapter_1 = require("./rabbitmq-event-adapter");
+Object.defineProperty(exports, "RabbitMQEventAdapter", { enumerable: true, get: function () { return rabbitmq_event_adapter_1.RabbitMQEventAdapter; } });

package/dist/rabbitmq-event-adapter.d.ts

@@ -0,0 +1,21 @@
+import type { Event, EventAdapter, QueueConfig, SubscriptionHandle } from '@motiadev/core';
+import type { RabbitMQEventAdapterConfig } from './types';
+export declare class RabbitMQEventAdapter implements EventAdapter {
+    private connection;
+    private channel;
+    private config;
+    private subscriptions;
+    private reconnecting;
+    private shutdownRequested;
+    constructor(config: RabbitMQEventAdapterConfig);
+    private ensureConnection;
+    private connect;
+    private handleConnectionError;
+    emit<TData>(event: Event<TData>): Promise<void>;
+    subscribe<TData>(topic: string, stepName: string, handler: (event: Event<TData>) => void | Promise<void>, options?: QueueConfig): Promise<SubscriptionHandle>;
+    unsubscribe(handle: SubscriptionHandle): Promise<void>;
+    shutdown(): Promise<void>;
+    getSubscriptionCount(topic: string): Promise<number>;
+    listTopics(): Promise<string[]>;
+}
+//# sourceMappingURL=rabbitmq-event-adapter.d.ts.map

package/dist/rabbitmq-event-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rabbitmq-event-adapter.d.ts","sourceRoot":"","sources":["../src/rabbitmq-event-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAG1F,OAAO,KAAK,EAAE,0BAA0B,EAA4B,MAAM,SAAS,CAAA;AAEnF,qBAAa,oBAAqB,YAAW,YAAY;IACvD,OAAO,CAAC,UAAU,CAA4B;IAC9C,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,MAAM,CAAsC;IACpD,OAAO,CAAC,aAAa,CAA6C;IAClE,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,iBAAiB,CAAQ;gBAErB,MAAM,EAAE,0BAA0B;YAWhC,gBAAgB;YAUhB,OAAO;YA4CP,qBAAqB;IAuB7B,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAyB/C,SAAS,CAAC,KAAK,EACnB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EACtD,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,kBAAkB,CAAC;IA4ExB,WAAW,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAMtD,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAyBzB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIpD,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAGtC"}

package/dist/rabbitmq-event-adapter.js

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMQEventAdapter = void 0;
+const amqplib_1 = __importDefault(require("amqplib"));
+class RabbitMQEventAdapter {
+    constructor(config) {
+        this.connection = null;
+        this.channel = null;
+        this.subscriptions = new Map();
+        this.reconnecting = false;
+        this.shutdownRequested = false;
+        this.config = {
+            durable: true,
+            autoDelete: false,
+            connectionTimeout: 10000,
+            reconnectDelay: 5000,
+            prefetch: 10,
+            ...config,
+        };
+    }
+    async ensureConnection() {
+        if (!this.connection || !this.channel) {
+            await this.connect();
+        }
+        if (!this.channel) {
+            throw new Error('Failed to establish channel');
+        }
+        return this.channel;
+    }
+    async connect() {
+        try {
+            this.connection = await amqplib_1.default.connect(this.config.url, {
+                timeout: this.config.connectionTimeout,
+            });
+            if (this.connection) {
+                this.connection.on('error', (err) => {
+                    console.error('[RabbitMQ] Connection error:', err);
+                    this.handleConnectionError();
+                });
+                this.connection.on('close', () => {
+                    console.warn('[RabbitMQ] Connection closed');
+                    this.handleConnectionError();
+                });
+                this.channel = await this.connection.createChannel();
+                if (this.channel) {
+                    this.channel.on('error', (err) => {
+                        console.error('[RabbitMQ] Channel error:', err);
+                    });
+                    this.channel.on('close', () => {
+                        console.warn('[RabbitMQ] Channel closed');
+                    });
+                    await this.channel.assertExchange(this.config.exchangeName, this.config.exchangeType, {
+                        durable: this.config.durable,
+                        autoDelete: this.config.autoDelete,
+                    });
+                    if (this.config.prefetch) {
+                        await this.channel.prefetch(this.config.prefetch);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('[RabbitMQ] Failed to connect:', error);
+            throw error;
+        }
+    }
+    async handleConnectionError() {
+        if (this.shutdownRequested || this.reconnecting) {
+            return;
+        }
+        this.reconnecting = true;
+        this.connection = null;
+        this.channel = null;
+        console.log(`[RabbitMQ] Attempting to reconnect in ${this.config.reconnectDelay}ms...`);
+        setTimeout(async () => {
+            try {
+                await this.connect();
+                this.reconnecting = false;
+            }
+            catch (error) {
+                console.error('[RabbitMQ] Reconnection failed:', error);
+                this.reconnecting = false;
+                this.handleConnectionError();
+            }
+        }, this.config.reconnectDelay);
+    }
+    async emit(event) {
+        const channel = await this.ensureConnection();
+        const message = {
+            topic: event.topic,
+            data: event.data,
+            traceId: event.traceId,
+            flows: event.flows,
+            messageGroupId: event.messageGroupId,
+            timestamp: Date.now(),
+        };
+        const content = Buffer.from(JSON.stringify(message));
+        const published = channel.publish(this.config.exchangeName, event.topic, content, {
+            persistent: this.config.durable,
+            contentType: 'application/json',
+            timestamp: Date.now(),
+        });
+        if (!published) {
+            throw new Error(`Failed to publish message to RabbitMQ for topic: ${event.topic}`);
+        }
+    }
+    async subscribe(topic, stepName, handler, options) {
+        const channel = await this.ensureConnection();
+        const queueName = `motia.${topic}.${stepName}`;
+        const subscribeOptions = {
+            durable: this.config.durable,
+            exclusive: false,
+            prefetch: this.config.prefetch,
+        };
+        const queueArgs = {};
+        if (options?.visibilityTimeout && options.visibilityTimeout > 0) {
+            queueArgs['x-consumer-timeout'] = options.visibilityTimeout * 1000;
+        }
+        if (options?.type === 'fifo') {
+            queueArgs['x-single-active-consumer'] = true;
+        }
+        const queue = await channel.assertQueue(queueName, {
+            durable: subscribeOptions.durable ?? true,
+            exclusive: subscribeOptions.exclusive ?? false,
+            autoDelete: !subscribeOptions.durable,
+            arguments: Object.keys(queueArgs).length > 0 ? queueArgs : undefined,
+        });
+        await channel.bindQueue(queue.queue, this.config.exchangeName, topic);
+        if (subscribeOptions.prefetch) {
+            await channel.prefetch(subscribeOptions.prefetch);
+        }
+        const consumerTag = await channel.consume(queue.queue, async (msg) => {
+            if (!msg)
+                return;
+            try {
+                const retryCount = msg.properties.headers?.['x-retry-count'] || 0;
+                if (options?.maxRetries && retryCount >= options.maxRetries) {
+                    console.warn(`[RabbitMQ] Message exceeded max retries (${options.maxRetries})`);
+                    channel.nack(msg, false, false);
+                    return;
+                }
+                const content = JSON.parse(msg.content.toString());
+                await handler(content);
+                channel.ack(msg);
+            }
+            catch (error) {
+                console.error('[RabbitMQ] Error processing message:', error);
+                if (options?.maxRetries) {
+                    const retryCount = msg.properties.headers?.['x-retry-count'] || 0;
+                    if (retryCount < options.maxRetries) {
+                        const headers = { ...msg.properties.headers, 'x-retry-count': retryCount + 1 };
+                        channel.publish(this.config.exchangeName, topic, msg.content, { ...msg.properties, headers });
+                    }
+                }
+                channel.nack(msg, false, false);
+            }
+        });
+        const handle = {
+            topic,
+            id: consumerTag.consumerTag,
+            unsubscribe: async () => {
+                await this.unsubscribe(handle);
+            },
+        };
+        this.subscriptions.set(handle.id, handle);
+        return handle;
+    }
+    async unsubscribe(handle) {
+        const channel = await this.ensureConnection();
+        await channel.cancel(handle.id);
+        this.subscriptions.delete(handle.id);
+    }
+    async shutdown() {
+        this.shutdownRequested = true;
+        if (this.channel) {
+            try {
+                await this.channel.close();
+            }
+            catch (error) {
+                console.error('[RabbitMQ] Error closing channel:', error);
+            }
+        }
+        if (this.connection) {
+            try {
+                const conn = this.connection;
+                if (typeof conn.close === 'function') {
+                    await conn.close();
+                }
+            }
+            catch (error) {
+                console.error('[RabbitMQ] Error closing connection:', error);
+            }
+        }
+        this.subscriptions.clear();
+    }
+    async getSubscriptionCount(topic) {
+        return Array.from(this.subscriptions.values()).filter((sub) => sub.topic === topic).length;
+    }
+    async listTopics() {
+        return Array.from(new Set(Array.from(this.subscriptions.values()).map((sub) => sub.topic)));
+    }
+}
+exports.RabbitMQEventAdapter = RabbitMQEventAdapter;

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+export interface RabbitMQEventAdapterConfig {
+    url: string;
+    exchangeName: string;
+    exchangeType: 'direct' | 'topic' | 'fanout' | 'headers';
+    durable?: boolean;
+    autoDelete?: boolean;
+    connectionTimeout?: number;
+    reconnectDelay?: number;
+    prefetch?: number;
+}
+export interface RabbitMQSubscribeOptions {
+    queue?: string;
+    exclusive?: boolean;
+    durable?: boolean;
+    prefetch?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,0BAA0B;IACzC,GAAG,EAAE,MAAM,CAAA;IACX,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAA;IACvD,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,wBAAwB;IACvC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB"}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@motiadev/adapter-rabbitmq-events",
+  "description": "RabbitMQ event adapter for Motia framework, enabling distributed event handling across multiple instances.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "version": "0.8.2-beta.140-709523",
+  "dependencies": {
+    "amqplib": "^0.10.4",
+    "uuid": "^11.1.0",
+    "@motiadev/core": "0.8.2-beta.140-709523"
+  },
+  "devDependencies": {
+    "@types/amqplib": "^0.10.5",
+    "typescript": "^5.7.2"
+  },
+  "peerDependencies": {
+    "@motiadev/core": "^0.8.0"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "lint": "biome check .",
+    "watch": "tsc --watch"
+  }
+}