@alt-javascript/camel-lite-component-amqp 1.0.2

package/README.md

@@ -0,0 +1,66 @@
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## What
+
+AMQP messaging supporting both AMQP 1.0 ([rhea](https://www.npmjs.com/package/rhea)) and AMQP 0-9-1 ([amqplib](https://www.npmjs.com/package/amqplib)). Producers send exchange body to a queue or topic; consumers receive messages and set them as the exchange body.
+
+## Install
+
+```sh
+npm install camel-lite-component-amqp
+```
+
+## URI Syntax
+
+```
+amqp:queue:name[?protocol=amqp10&url=amqp://localhost]
+amqp:topic:name[?protocol=amqp10&url=amqp://localhost]
+```
+
+| Parameter  | Default         | Description |
+|------------|-----------------|-------------|
+| `protocol` | `amqp10`        | Wire protocol: `amqp10` (AMQP 1.0 via rhea) or `amqp091` (AMQP 0-9-1 via amqplib). |
+| `url`      | `amqp://localhost` | Broker connection URL. |
+
+## Usage
+
+**Producer — send to a queue:**
+
+```js
+import { CamelContext } from 'camel-lite-core';
+import { AmqpComponent } from 'camel-lite-component-amqp';
+
+const context = new CamelContext();
+context.addComponent('amqp', new AmqpComponent());
+
+context.addRoutes({
+  configure(ctx) {
+    ctx.from('direct:send')
+      .to('amqp:queue:orders?protocol=amqp10&url=amqp://localhost:5672');
+  }
+});
+
+await context.start();
+
+const template = context.createProducerTemplate();
+await template.sendBody('direct:send', JSON.stringify({ orderId: 42 }));
+
+await context.stop();
+```
+
+**Consumer — receive from a queue:**
+
+```js
+context.addRoutes({
+  configure(ctx) {
+    ctx.from('amqp:queue:orders?protocol=amqp10&url=amqp://localhost:5672')
+      .process(exchange => {
+        console.log('Received:', exchange.in.body);
+      });
+  }
+});
+```
+
+## See Also
+
+[camel-lite — root README](../../README.md)

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@alt-javascript/camel-lite-component-amqp",
+  "version": "1.0.2",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "dependencies": {
+    "rhea": "^3.0.4",
+    "amqplib": "^0.10.0",
+    "@alt-javascript/logger": "^3.0.7",
+    "@alt-javascript/config": "^3.0.7",
+    "@alt-javascript/common": "^3.0.7",
+    "@alt-javascript/camel-lite-core": "1.0.2"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alt-javascript/camel-lite"
+  },
+  "author": "Craig Parravicini",
+  "contributors": [
+    "Claude (Anthropic)",
+    "Apache Camel — design inspiration and pattern source"
+  ],
+  "keywords": [
+    "alt-javascript",
+    "camel",
+    "camel-lite",
+    "eai",
+    "eip",
+    "integration",
+    "amqp",
+    "messaging",
+    "rabbitmq",
+    "activemq",
+    "component"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/src/Amqp091Consumer.js

@@ -0,0 +1,89 @@
+import { Consumer, Exchange } from '@alt-javascript/camel-lite-core';
+import { LoggerFactory } from '@alt-javascript/logger';
+import { JmsMapper } from './JmsMapper.js';
+import { connect } from './AmqplibClientFactory.js';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/Amqp091Consumer');
+
+/**
+ * Receives AMQP 0-9-1 messages via amqplib and drives each through the routing pipeline.
+ * Maintains a persistent connection from start() to stop().
+ */
+class Amqp091Consumer extends Consumer {
+  #endpoint;
+  #pipeline;
+  #connection = null;
+  #channel = null;
+
+  constructor(endpoint, pipeline) {
+    super();
+    this.#endpoint = endpoint;
+    this.#pipeline = pipeline;
+  }
+
+  async start() {
+    const { host, port, queue, jmsMapping, clientFactory, context, uri } = this.#endpoint;
+    const url = `amqp://${host}:${port}`;
+    const brokerRef = `${host}:${port}/${queue}`;
+
+    context.registerConsumer(uri, this);
+
+    const conn = clientFactory ? await clientFactory(url) : await connect(url);
+    this.#connection = conn;
+
+    const ch = await conn.createChannel();
+    this.#channel = ch;
+
+    await ch.assertQueue(queue, { durable: false });
+
+    ch.consume(queue, (msg) => {
+      if (!msg) return; // consumer cancelled
+
+      log.debug(`AMQP 0-9-1 received ← ${brokerRef}`);
+
+      const exchange = new Exchange();
+      exchange.in.body = msg.content.toString('utf8');
+
+      if (jmsMapping) {
+        JmsMapper.fromAmqp091(msg, exchange);
+      }
+
+      ch.ack(msg);
+
+      this.#pipeline.run(exchange).catch((err) => {
+        log.error(`AMQP 0-9-1 pipeline error on ${brokerRef}: ${err.message}`);
+      });
+    });
+
+    log.info(`AMQP 0-9-1 consumer connected: ${brokerRef}`);
+  }
+
+  async stop() {
+    const { host, port, queue, context, uri } = this.#endpoint;
+    const brokerRef = `${host}:${port}/${queue}`;
+
+    try {
+      if (this.#channel) {
+        await this.#channel.close().catch(() => { /* already closed */ });
+        this.#channel = null;
+      }
+      if (this.#connection) {
+        await this.#connection.close().catch(() => { /* already closed */ });
+        this.#connection = null;
+      }
+    } catch {
+      /* swallow — we're stopping */
+    }
+
+    context.registerConsumer(uri, null);
+    log.info(`AMQP 0-9-1 consumer stopped: ${brokerRef}`);
+  }
+
+  /** Called by integration tests to inject a single message into the pipeline. */
+  async process(exchange) {
+    return this.#pipeline.run(exchange);
+  }
+}
+
+export { Amqp091Consumer };
+export default Amqp091Consumer;

package/src/Amqp091Endpoint.js

@@ -0,0 +1,29 @@
+import { AmqpEndpointBase } from './AmqpEndpointBase.js';
+import { Amqp091Producer } from './Amqp091Producer.js';
+import { Amqp091Consumer } from './Amqp091Consumer.js';
+
+/**
+ * AMQP 0-9-1 endpoint (backed by amqplib, for RabbitMQ).
+ * clientFactory is injected for testability; defaults to the amqplib factory wired in AmqpComponent.
+ */
+class Amqp091Endpoint extends AmqpEndpointBase {
+  #clientFactory;
+
+  constructor(uri, host, port, queue, jmsMapping, context, component, clientFactory) {
+    super(uri, host, port, queue, jmsMapping, context, component);
+    this.#clientFactory = clientFactory;
+  }
+
+  get clientFactory() { return this.#clientFactory; }
+
+  createProducer() {
+    return new Amqp091Producer(this);
+  }
+
+  createConsumer(pipeline) {
+    return new Amqp091Consumer(this, pipeline);
+  }
+}
+
+export { Amqp091Endpoint };
+export default Amqp091Endpoint;

package/src/Amqp091Producer.js

@@ -0,0 +1,58 @@
+import { Producer } from '@alt-javascript/camel-lite-core';
+import { LoggerFactory } from '@alt-javascript/logger';
+import { JmsMapper } from './JmsMapper.js';
+import { connect } from './AmqplibClientFactory.js';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/Amqp091Producer');
+
+/**
+ * Sends a single exchange as an AMQP 0-9-1 message via amqplib.
+ * Opens a connection per send() call (stateless producer).
+ */
+class Amqp091Producer extends Producer {
+  #endpoint;
+
+  constructor(endpoint) {
+    super();
+    this.#endpoint = endpoint;
+  }
+
+  async send(exchange) {
+    const { host, port, queue, jmsMapping, clientFactory } = this.#endpoint;
+    const url = `amqp://${host}:${port}`;
+    const brokerRef = `${host}:${port}/${queue}`;
+
+    // clientFactory can return a mock connection for tests
+    const conn = clientFactory ? await clientFactory(url) : await connect(url);
+    try {
+      const ch = await conn.createChannel();
+      try {
+        await ch.assertQueue(queue, { durable: false });
+
+        const body = exchange.in.body;
+        const content = typeof body === 'string'
+          ? Buffer.from(body, 'utf8')
+          : Buffer.isBuffer(body)
+            ? body
+            : Buffer.from(JSON.stringify(body), 'utf8');
+
+        const options = {};
+        if (jmsMapping) {
+          JmsMapper.toAmqp091(exchange, options);
+        }
+
+        log.debug(`AMQP 0-9-1 send → ${brokerRef}`);
+        ch.sendToQueue(queue, content, options);
+        await ch.close();
+      } finally {
+        await ch.close().catch(() => { /* already closed */ });
+      }
+    } finally {
+      await conn.close().catch(() => { /* already closed */ });
+      log.debug(`AMQP 0-9-1 connection closed: ${brokerRef}`);
+    }
+  }
+}
+
+export { Amqp091Producer };
+export default Amqp091Producer;

package/src/Amqp10Consumer.js

@@ -0,0 +1,100 @@
+import { Consumer, Exchange } from '@alt-javascript/camel-lite-core';
+import { LoggerFactory } from '@alt-javascript/logger';
+import { JmsMapper } from './JmsMapper.js';
+import { createContainer } from './RheaClientFactory.js';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/Amqp10Consumer');
+
+/**
+ * Receives AMQP 1.0 messages via rhea and drives each through the routing pipeline.
+ * Maintains a persistent connection from start() to stop().
+ * stop() signals the AbortController and closes the connection gracefully.
+ */
+class Amqp10Consumer extends Consumer {
+  #endpoint;
+  #pipeline;
+  #connection = null;
+
+  constructor(endpoint, pipeline) {
+    super();
+    this.#endpoint = endpoint;
+    this.#pipeline = pipeline;
+  }
+
+  async start() {
+    const { host, port, queue, jmsMapping, clientFactory, context, uri } = this.#endpoint;
+    const brokerRef = `${host}:${port}/${queue}`;
+
+    context.registerConsumer(uri, this);
+
+    const container = clientFactory ? clientFactory() : createContainer();
+
+    await new Promise((resolve, reject) => {
+      const conn = container.connect({ host, port: Number(port) });
+      this.#connection = conn;
+
+      conn.on('connection_open', () => {
+        conn.open_receiver(queue);
+        log.info(`AMQP 1.0 consumer connected: ${brokerRef}`);
+        resolve();
+      });
+
+      conn.on('message', (ctx) => {
+        const msg = ctx.message;
+        log.debug(`AMQP 1.0 received ← ${brokerRef}`);
+
+        const exchange = new Exchange();
+        const body = msg.body;
+        exchange.in.body = Buffer.isBuffer(body) ? body.toString('utf8') : body;
+
+        if (jmsMapping) {
+          JmsMapper.fromAmqp10(msg, exchange);
+        }
+
+        // Fire-and-forget pipeline execution; exceptions land on exchange.exception
+        this.#pipeline.run(exchange).catch((err) => {
+          log.error(`AMQP 1.0 pipeline error on ${brokerRef}: ${err.message}`);
+        });
+      });
+
+      conn.on('disconnected', (ctx) => {
+        if (ctx.error) {
+          log.error(`AMQP 1.0 disconnected from ${brokerRef}: ${ctx.error.message}`);
+          reject(ctx.error);
+        }
+      });
+    });
+  }
+
+  async stop() {
+    const { host, port, queue, context, uri } = this.#endpoint;
+    const brokerRef = `${host}:${port}/${queue}`;
+
+    if (this.#connection) {
+      await new Promise((resolve) => {
+        const conn = this.#connection;
+        this.#connection = null;
+
+        conn.once('connection_close', () => resolve());
+        conn.once('disconnected', () => resolve());
+
+        try {
+          conn.close();
+        } catch {
+          resolve();
+        }
+      });
+    }
+
+    context.registerConsumer(uri, null);
+    log.info(`AMQP 1.0 consumer stopped: ${brokerRef}`);
+  }
+
+  /** Called by integration tests to inject a single message into the pipeline. */
+  async process(exchange) {
+    return this.#pipeline.run(exchange);
+  }
+}
+
+export { Amqp10Consumer };
+export default Amqp10Consumer;

package/src/Amqp10Endpoint.js

@@ -0,0 +1,29 @@
+import { AmqpEndpointBase } from './AmqpEndpointBase.js';
+import { Amqp10Producer } from './Amqp10Producer.js';
+import { Amqp10Consumer } from './Amqp10Consumer.js';
+
+/**
+ * AMQP 1.0 endpoint (backed by rhea).
+ * clientFactory is injected for testability; defaults to the rhea factory wired in AmqpComponent.
+ */
+class Amqp10Endpoint extends AmqpEndpointBase {
+  #clientFactory;
+
+  constructor(uri, host, port, queue, jmsMapping, context, component, clientFactory) {
+    super(uri, host, port, queue, jmsMapping, context, component);
+    this.#clientFactory = clientFactory;
+  }
+
+  get clientFactory() { return this.#clientFactory; }
+
+  createProducer() {
+    return new Amqp10Producer(this);
+  }
+
+  createConsumer(pipeline) {
+    return new Amqp10Consumer(this, pipeline);
+  }
+}
+
+export { Amqp10Endpoint };
+export default Amqp10Endpoint;

package/src/Amqp10Producer.js

@@ -0,0 +1,75 @@
+import { Producer } from '@alt-javascript/camel-lite-core';
+import { LoggerFactory } from '@alt-javascript/logger';
+import { JmsMapper } from './JmsMapper.js';
+import { createContainer } from './RheaClientFactory.js';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/Amqp10Producer');
+
+/**
+ * Sends a single exchange as an AMQP 1.0 message via rhea.
+ * Opens a connection per send() call (stateless — no persistent connection for producers).
+ * The connection is closed after the message is sent/rejected/released.
+ */
+class Amqp10Producer extends Producer {
+  #endpoint;
+
+  constructor(endpoint) {
+    super();
+    this.#endpoint = endpoint;
+  }
+
+  async send(exchange) {
+    const { host, port, queue, jmsMapping, clientFactory } = this.#endpoint;
+    const brokerRef = `${host}:${port}/${queue}`;
+
+    // clientFactory can override container creation for tests
+    const container = clientFactory ? clientFactory() : createContainer();
+
+    return new Promise((resolve, reject) => {
+      const conn = container.connect({ host, port: Number(port) });
+
+      conn.on('connection_open', () => {
+        const sender = conn.open_sender(queue);
+
+        sender.on('sendable', () => {
+          const body = exchange.in.body;
+          const content = typeof body === 'string' || Buffer.isBuffer(body)
+            ? body
+            : JSON.stringify(body);
+
+          const message = { body: content };
+
+          if (jmsMapping) {
+            JmsMapper.toAmqp10(exchange, message);
+          }
+
+          log.debug(`AMQP 1.0 send → ${brokerRef}`);
+          sender.send(message);
+          sender.close();
+          conn.close();
+        });
+
+        sender.on('rejected', (ctx) => {
+          conn.close();
+          const err = new Error(`AMQP 1.0 message rejected by ${brokerRef}: ${JSON.stringify(ctx.delivery?.remote_state)}`);
+          log.error(err.message);
+          reject(err);
+        });
+      });
+
+      conn.on('connection_close', () => {
+        resolve();
+      });
+
+      conn.on('disconnected', (ctx) => {
+        if (ctx.error) {
+          log.error(`AMQP 1.0 disconnected from ${brokerRef}: ${ctx.error.message}`);
+          reject(ctx.error);
+        }
+      });
+    });
+  }
+}
+
+export { Amqp10Producer };
+export default Amqp10Producer;

package/src/AmqpComponent.js

@@ -0,0 +1,97 @@
+import { Component } from '@alt-javascript/camel-lite-core';
+import { LoggerFactory } from '@alt-javascript/logger';
+import { Amqp10Endpoint } from './Amqp10Endpoint.js';
+import { Amqp091Endpoint } from './Amqp091Endpoint.js';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/AmqpComponent');
+
+/**
+ * AmqpComponent — dual-protocol AMQP component.
+ *
+ * URI format:
+ *   amqp://host:port/queue?protocol=1.0&jms=false
+ *   amqp://host:port/queue?protocol=0-9-1&jms=true
+ *
+ * protocol: '1.0' (default) → rhea / AMQP 1.0 (Artemis, Azure Service Bus)
+ * protocol: '0-9-1'         → amqplib / AMQP 0-9-1 (RabbitMQ)
+ * jms:      'true'          → apply JMS 2.x header mapping
+ *
+ * clientFactory (optional): inject a factory fn for testing.
+ *   setClientFactory10(fn)   — for AMQP 1.0 tests
+ *   setClientFactory091(fn)  — for AMQP 0-9-1 tests
+ */
+class AmqpComponent extends Component {
+  #endpoints = new Map();
+  #clientFactory10 = null;
+  #clientFactory091 = null;
+
+  /** Inject a custom AMQP 1.0 connection factory (for unit tests). */
+  setClientFactory10(fn) {
+    this.#clientFactory10 = fn;
+    return this;
+  }
+
+  /** Inject a custom AMQP 0-9-1 connection factory (for unit tests). */
+  setClientFactory091(fn) {
+    this.#clientFactory091 = fn;
+    return this;
+  }
+
+  createEndpoint(uri, remaining, parameters, context) {
+    if (this.#endpoints.has(uri)) {
+      return this.#endpoints.get(uri);
+    }
+
+    // Parse: uri = 'amqp://host:port/queue?...'
+    // CamelContext passes us: uri = full URI, remaining = everything after 'amqp:', params = URLSearchParams
+    // But remaining may be '//host:port/queue' — we parse from the full URI string.
+    const { host, port, queue, protocol, jmsMapping } = AmqpComponent.#parseUri(uri, parameters);
+
+    log.info(`AmqpComponent creating endpoint: protocol=${protocol}, host=${host}:${port}, queue=${queue}, jms=${jmsMapping}`);
+
+    let endpoint;
+    if (protocol === '0-9-1') {
+      endpoint = new Amqp091Endpoint(uri, host, port, queue, jmsMapping, context, this, this.#clientFactory091);
+    } else {
+      // Default: AMQP 1.0
+      endpoint = new Amqp10Endpoint(uri, host, port, queue, jmsMapping, context, this, this.#clientFactory10);
+    }
+
+    this.#endpoints.set(uri, endpoint);
+    return endpoint;
+  }
+
+  static #parseUri(uri, parameters) {
+    // uri examples:
+    //   amqp://localhost:5672/myqueue?protocol=1.0&jms=true
+    //   amqp://localhost:5672/myqueue
+    // We extract host, port, queue from the URI string directly (case-preserving).
+
+    let working = uri;
+
+    // Strip scheme
+    const schemeEnd = working.indexOf('://');
+    if (schemeEnd >= 0) working = working.slice(schemeEnd + 3);
+
+    // Strip query string (already in parameters)
+    const qIdx = working.indexOf('?');
+    if (qIdx >= 0) working = working.slice(0, qIdx);
+
+    // working = 'host:port/queue'
+    const slashIdx = working.indexOf('/');
+    const hostPort = slashIdx >= 0 ? working.slice(0, slashIdx) : working;
+    const queue = slashIdx >= 0 ? working.slice(slashIdx + 1) : 'default';
+
+    const colonIdx = hostPort.lastIndexOf(':');
+    const host = colonIdx >= 0 ? hostPort.slice(0, colonIdx) : hostPort;
+    const port = colonIdx >= 0 ? parseInt(hostPort.slice(colonIdx + 1), 10) : 5672;
+
+    const protocol = parameters.get('protocol') ?? '1.0';
+    const jmsMapping = parameters.get('jms') === 'true';
+
+    return { host, port, queue, protocol, jmsMapping };
+  }
+}
+
+export { AmqpComponent };
+export default AmqpComponent;

package/src/AmqpEndpointBase.js

@@ -0,0 +1,37 @@
+import { Endpoint } from '@alt-javascript/camel-lite-core';
+
+/**
+ * Shared base for AMQP endpoints.
+ * Holds the parsed URI state; subclasses provide createProducer/createConsumer.
+ */
+class AmqpEndpointBase extends Endpoint {
+  #uri;
+  #host;
+  #port;
+  #queue;
+  #jmsMapping;
+  #context;
+  #component;
+
+  constructor(uri, host, port, queue, jmsMapping, context, component) {
+    super();
+    this.#uri = uri;
+    this.#host = host;
+    this.#port = port;
+    this.#queue = queue;
+    this.#jmsMapping = jmsMapping;
+    this.#context = context;
+    this.#component = component;
+  }
+
+  get uri() { return this.#uri; }
+  get host() { return this.#host; }
+  get port() { return this.#port; }
+  get queue() { return this.#queue; }
+  get jmsMapping() { return this.#jmsMapping; }
+  get context() { return this.#context; }
+  get component() { return this.#component; }
+}
+
+export { AmqpEndpointBase };
+export default AmqpEndpointBase;

package/src/AmqplibClientFactory.js

@@ -0,0 +1,23 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+/**
+ * ESM/CJS bridge for amqplib (AMQP 0-9-1).
+ * Single point of CJS import — keeps the rest of the package pure ESM.
+ */
+let _amqplib;
+
+export function getAmqplib() {
+  if (!_amqplib) {
+    _amqplib = require('amqplib');
+  }
+  return _amqplib;
+}
+
+/**
+ * @param {string} url - amqp://user:pass@host:port/vhost
+ * @returns {Promise<import('amqplib').Connection>}
+ */
+export async function connect(url) {
+  return getAmqplib().connect(url);
+}

package/src/JmsMapper.js

@@ -0,0 +1,121 @@
+/**
+ * JmsMapper — bidirectional mapping between JMS 2.x message properties
+ * and AMQP message annotations/properties.
+ *
+ * JMS 2.x → AMQP 1.0 property names (as used by Qpid JMS / Artemis):
+ *   JMSMessageID      ↔  message-id        (application-properties or properties.message_id)
+ *   JMSCorrelationID  ↔  correlation-id    (properties.correlation_id)
+ *   JMSTimestamp      ↔  creation-time     (properties.creation_time, epoch ms)
+ *   JMSType           ↔  subject           (properties.subject)
+ *   JMSDeliveryMode   ↔  durable           (header.durable: true = PERSISTENT)
+ *   JMSPriority       ↔  priority          (header.priority)
+ *   JMSExpiration     ↔  absolute-expiry-time (properties.absolute_expiry_time)
+ *
+ * For AMQP 0-9-1 (amqplib) the AMQP message properties map is:
+ *   JMSMessageID      ↔  messageId
+ *   JMSCorrelationID  ↔  correlationId
+ *   JMSTimestamp      ↔  timestamp  (Date)
+ *   JMSType           ↔  type
+ */
+
+export const JmsMapper = {
+  /**
+   * Copy JMS headers from exchange to an outbound AMQP 1.0 (rhea) message object.
+   * @param {import('@alt-javascript/camel-lite-core').Exchange} exchange
+   * @param {object} message  - rhea message object (mutated in place)
+   */
+  toAmqp10(exchange, message) {
+    const h = exchange.in;
+    const props = message.properties ?? {};
+    message.properties = props;
+
+    const mid = h.getHeader('JMSMessageID');
+    if (mid != null) props.message_id = String(mid);
+
+    const cid = h.getHeader('JMSCorrelationID');
+    if (cid != null) props.correlation_id = String(cid);
+
+    const ts = h.getHeader('JMSTimestamp');
+    if (ts != null) props.creation_time = Number(ts);
+
+    const type = h.getHeader('JMSType');
+    if (type != null) props.subject = String(type);
+
+    const dm = h.getHeader('JMSDeliveryMode');
+    if (dm != null) {
+      message.header = message.header ?? {};
+      message.header.durable = (dm === 'PERSISTENT' || dm === 2);
+    }
+
+    const pri = h.getHeader('JMSPriority');
+    if (pri != null) {
+      message.header = message.header ?? {};
+      message.header.priority = Number(pri);
+    }
+  },
+
+  /**
+   * Copy AMQP 1.0 (rhea) message properties to JMS headers on the exchange.
+   * @param {object} message  - rhea message object
+   * @param {import('@alt-javascript/camel-lite-core').Exchange} exchange
+   */
+  fromAmqp10(message, exchange) {
+    const props = message.properties ?? {};
+    const h = exchange.in;
+
+    if (props.message_id != null) h.setHeader('JMSMessageID', String(props.message_id));
+    if (props.correlation_id != null) h.setHeader('JMSCorrelationID', String(props.correlation_id));
+    if (props.creation_time != null) h.setHeader('JMSTimestamp', Number(props.creation_time));
+    if (props.subject != null) h.setHeader('JMSType', String(props.subject));
+
+    const hdr = message.header ?? {};
+    if (hdr.durable != null) h.setHeader('JMSDeliveryMode', hdr.durable ? 'PERSISTENT' : 'NON_PERSISTENT');
+    if (hdr.priority != null) h.setHeader('JMSPriority', hdr.priority);
+  },
+
+  /**
+   * Copy JMS headers from exchange to an outbound amqplib 0-9-1 message options object.
+   * @param {import('@alt-javascript/camel-lite-core').Exchange} exchange
+   * @param {object} options  - amqplib sendToQueue options (mutated in place)
+   */
+  toAmqp091(exchange, options) {
+    const h = exchange.in;
+
+    const mid = h.getHeader('JMSMessageID');
+    if (mid != null) options.messageId = String(mid);
+
+    const cid = h.getHeader('JMSCorrelationID');
+    if (cid != null) options.correlationId = String(cid);
+
+    const ts = h.getHeader('JMSTimestamp');
+    if (ts != null) options.timestamp = Math.floor(Number(ts) / 1000); // amqplib: seconds
+
+    const type = h.getHeader('JMSType');
+    if (type != null) options.type = String(type);
+
+    const dm = h.getHeader('JMSDeliveryMode');
+    if (dm != null) options.deliveryMode = (dm === 'PERSISTENT' || dm === 2) ? 2 : 1;
+
+    const pri = h.getHeader('JMSPriority');
+    if (pri != null) options.priority = Number(pri);
+  },
+
+  /**
+   * Copy amqplib 0-9-1 message properties to JMS headers on the exchange.
+   * @param {object} msg  - amqplib message object (msg.properties)
+   * @param {import('@alt-javascript/camel-lite-core').Exchange} exchange
+   */
+  fromAmqp091(msg, exchange) {
+    const props = msg.properties ?? {};
+    const h = exchange.in;
+
+    if (props.messageId != null) h.setHeader('JMSMessageID', String(props.messageId));
+    if (props.correlationId != null) h.setHeader('JMSCorrelationID', String(props.correlationId));
+    if (props.timestamp != null) h.setHeader('JMSTimestamp', Number(props.timestamp) * 1000); // back to ms
+    if (props.type != null) h.setHeader('JMSType', String(props.type));
+    if (props.deliveryMode != null) h.setHeader('JMSDeliveryMode', props.deliveryMode === 2 ? 'PERSISTENT' : 'NON_PERSISTENT');
+    if (props.priority != null) h.setHeader('JMSPriority', props.priority);
+  },
+};
+
+export default JmsMapper;

package/src/RheaClientFactory.js

@@ -0,0 +1,19 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+/**
+ * ESM/CJS bridge for rhea (AMQP 1.0).
+ * Single point of CJS import — keeps the rest of the package pure ESM.
+ */
+let _rhea;
+
+export function getRhea() {
+  if (!_rhea) {
+    _rhea = require('rhea');
+  }
+  return _rhea;
+}
+
+export function createContainer() {
+  return getRhea().create_container();
+}

package/src/index.js

@@ -0,0 +1,9 @@
+export { AmqpComponent } from './AmqpComponent.js';
+export { AmqpEndpointBase } from './AmqpEndpointBase.js';
+export { Amqp10Endpoint } from './Amqp10Endpoint.js';
+export { Amqp091Endpoint } from './Amqp091Endpoint.js';
+export { Amqp10Producer } from './Amqp10Producer.js';
+export { Amqp091Producer } from './Amqp091Producer.js';
+export { Amqp10Consumer } from './Amqp10Consumer.js';
+export { Amqp091Consumer } from './Amqp091Consumer.js';
+export { JmsMapper } from './JmsMapper.js';

package/test/amqp.test.js

@@ -0,0 +1,528 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { Exchange, CamelContext, RouteBuilder } from '@alt-javascript/camel-lite-core';
+import { AmqpComponent, JmsMapper } from '@alt-javascript/camel-lite-component-amqp';
+
+// ---------------------------------------------------------------------------
+// T02: AmqpComponent URI parsing + AmqpProducer unit tests
+// T03: AmqpConsumer lifecycle unit tests
+// ---------------------------------------------------------------------------
+
+// ── helpers ─────────────────────────────────────────────────────────────────
+
+function makeExchange(body = 'hello amqp') {
+  const ex = new Exchange();
+  ex.in.body = body;
+  return ex;
+}
+
+// ── JmsMapper unit tests ─────────────────────────────────────────────────────
+
+describe('JmsMapper', () => {
+  it('toAmqp10: maps JMS headers onto rhea message properties', () => {
+    const ex = makeExchange();
+    ex.in.setHeader('JMSMessageID', 'ID:12345');
+    ex.in.setHeader('JMSCorrelationID', 'corr-abc');
+    ex.in.setHeader('JMSTimestamp', 1700000000000);
+    ex.in.setHeader('JMSType', 'OrderCreated');
+    ex.in.setHeader('JMSDeliveryMode', 'PERSISTENT');
+    ex.in.setHeader('JMSPriority', 5);
+
+    const msg = {};
+    JmsMapper.toAmqp10(ex, msg);
+
+    assert.equal(msg.properties.message_id, 'ID:12345');
+    assert.equal(msg.properties.correlation_id, 'corr-abc');
+    assert.equal(msg.properties.creation_time, 1700000000000);
+    assert.equal(msg.properties.subject, 'OrderCreated');
+    assert.equal(msg.header.durable, true);
+    assert.equal(msg.header.priority, 5);
+  });
+
+  it('fromAmqp10: maps rhea message properties to JMS headers on exchange', () => {
+    const ex = makeExchange();
+    const msg = {
+      properties: {
+        message_id: 'ID:99',
+        correlation_id: 'corr-xyz',
+        creation_time: 1700000001000,
+        subject: 'OrderShipped',
+      },
+      header: { durable: false, priority: 3 },
+    };
+
+    JmsMapper.fromAmqp10(msg, ex);
+
+    assert.equal(ex.in.getHeader('JMSMessageID'), 'ID:99');
+    assert.equal(ex.in.getHeader('JMSCorrelationID'), 'corr-xyz');
+    assert.equal(ex.in.getHeader('JMSTimestamp'), 1700000001000);
+    assert.equal(ex.in.getHeader('JMSType'), 'OrderShipped');
+    assert.equal(ex.in.getHeader('JMSDeliveryMode'), 'NON_PERSISTENT');
+    assert.equal(ex.in.getHeader('JMSPriority'), 3);
+  });
+
+  it('toAmqp091: maps JMS headers onto amqplib options', () => {
+    const ex = makeExchange();
+    ex.in.setHeader('JMSMessageID', 'ID:55');
+    ex.in.setHeader('JMSCorrelationID', 'corr-091');
+    ex.in.setHeader('JMSTimestamp', 1700000002000);
+    ex.in.setHeader('JMSType', 'Ping');
+    ex.in.setHeader('JMSDeliveryMode', 'NON_PERSISTENT');
+
+    const options = {};
+    JmsMapper.toAmqp091(ex, options);
+
+    assert.equal(options.messageId, 'ID:55');
+    assert.equal(options.correlationId, 'corr-091');
+    assert.equal(options.timestamp, 1700000002); // seconds
+    assert.equal(options.type, 'Ping');
+    assert.equal(options.deliveryMode, 1); // NON_PERSISTENT
+  });
+
+  it('fromAmqp091: maps amqplib message properties to JMS headers', () => {
+    const ex = makeExchange();
+    const msg = {
+      properties: {
+        messageId: 'ID:77',
+        correlationId: 'corr-77',
+        timestamp: 1700000003, // seconds
+        type: 'Pong',
+        deliveryMode: 2,
+        priority: 7,
+      },
+    };
+
+    JmsMapper.fromAmqp091(msg, ex);
+
+    assert.equal(ex.in.getHeader('JMSMessageID'), 'ID:77');
+    assert.equal(ex.in.getHeader('JMSCorrelationID'), 'corr-77');
+    assert.equal(ex.in.getHeader('JMSTimestamp'), 1700000003000); // back to ms
+    assert.equal(ex.in.getHeader('JMSType'), 'Pong');
+    assert.equal(ex.in.getHeader('JMSDeliveryMode'), 'PERSISTENT');
+    assert.equal(ex.in.getHeader('JMSPriority'), 7);
+  });
+
+  it('toAmqp10: skips unmapped headers gracefully', () => {
+    const msg = {};
+    JmsMapper.toAmqp10(makeExchange(), msg); // no JMS headers set
+    assert.deepEqual(msg, { properties: {} });
+  });
+});
+
+// ── AmqpComponent URI parsing ────────────────────────────────────────────────
+
+describe('AmqpComponent URI parsing', () => {
+  const ctx = new CamelContext();
+
+  it('defaults to AMQP 1.0 when protocol param absent', () => {
+    const comp = new AmqpComponent();
+    const params = new URLSearchParams();
+    const ep = comp.createEndpoint('amqp://localhost:5672/testqueue', '//localhost:5672/testqueue', params, ctx);
+    assert.equal(ep.host, 'localhost');
+    assert.equal(ep.port, 5672);
+    assert.equal(ep.queue, 'testqueue');
+    assert.equal(ep.jmsMapping, false);
+    assert.match(ep.constructor.name, /Amqp10Endpoint/);
+  });
+
+  it('creates Amqp10Endpoint for protocol=1.0', () => {
+    const comp = new AmqpComponent();
+    const params = new URLSearchParams('protocol=1.0&jms=true');
+    const ep = comp.createEndpoint('amqp://broker:5672/orders?protocol=1.0&jms=true', '//broker:5672/orders', params, ctx);
+    assert.equal(ep.host, 'broker');
+    assert.equal(ep.port, 5672);
+    assert.equal(ep.queue, 'orders');
+    assert.equal(ep.jmsMapping, true);
+    assert.match(ep.constructor.name, /Amqp10Endpoint/);
+  });
+
+  it('creates Amqp091Endpoint for protocol=0-9-1', () => {
+    const comp = new AmqpComponent();
+    const params = new URLSearchParams('protocol=0-9-1');
+    const ep = comp.createEndpoint('amqp://rabbit:5672/events?protocol=0-9-1', '//rabbit:5672/events', params, ctx);
+    assert.equal(ep.queue, 'events');
+    assert.match(ep.constructor.name, /Amqp091Endpoint/);
+  });
+
+  it('returns cached endpoint on duplicate URI', () => {
+    const comp = new AmqpComponent();
+    const params = new URLSearchParams();
+    const ep1 = comp.createEndpoint('amqp://localhost:5672/q', '', params, ctx);
+    const ep2 = comp.createEndpoint('amqp://localhost:5672/q', '', params, ctx);
+    assert.equal(ep1, ep2);
+  });
+});
+
+// ── Amqp10Producer unit test (mock container) ────────────────────────────────
+
+describe('Amqp10Producer', () => {
+  it('sends exchange body as AMQP 1.0 message via mock container', async () => {
+    const sent = [];
+
+    // Mock rhea container
+    function mockFactory() {
+      return {
+        connect({ host, port }) {
+          const listeners = {};
+          const conn = {
+            on(event, fn) { listeners[event] = fn; return conn; },
+            once(event, fn) { listeners[event] = fn; return conn; },
+            open_sender(queue) {
+              // Emit 'sendable' asynchronously so the producer wires up first
+              const senderListeners = {};
+              const sender = {
+                on(ev, fn) { senderListeners[ev] = fn; return sender; },
+                send(msg) { sent.push({ queue, msg }); },
+                close() {
+                  // trigger connection_close after sender close
+                  setTimeout(() => listeners['connection_close']?.(), 0);
+                },
+              };
+              setTimeout(() => senderListeners['sendable']?.(), 0);
+              return sender;
+            },
+            close() { /* trigger via sender.close above */ },
+          };
+          // Emit connection_open after a tick
+          setTimeout(() => listeners['connection_open']?.(), 0);
+          return conn;
+        },
+      };
+    }
+
+    const comp = new AmqpComponent();
+    comp.setClientFactory10(mockFactory);
+
+    const params = new URLSearchParams('protocol=1.0');
+    const ctx = new CamelContext();
+    const ep = comp.createEndpoint('amqp://localhost:5672/myqueue?protocol=1.0', '', params, ctx);
+    const producer = ep.createProducer();
+
+    const ex = makeExchange('hello from producer');
+    await producer.send(ex);
+
+    assert.equal(sent.length, 1);
+    assert.equal(sent[0].queue, 'myqueue');
+    assert.equal(sent[0].msg.body, 'hello from producer');
+  });
+
+  it('applies JMS mapping when jmsMapping=true', async () => {
+    const sent = [];
+
+    function mockFactory() {
+      return {
+        connect() {
+          const listeners = {};
+          const conn = {
+            on(event, fn) { listeners[event] = fn; return conn; },
+            once(event, fn) { listeners[event] = fn; return conn; },
+            open_sender(queue) {
+              const senderListeners = {};
+              const sender = {
+                on(ev, fn) { senderListeners[ev] = fn; return sender; },
+                send(msg) { sent.push(msg); },
+                close() { setTimeout(() => listeners['connection_close']?.(), 0); },
+              };
+              setTimeout(() => senderListeners['sendable']?.(), 0);
+              return sender;
+            },
+            close() {},
+          };
+          setTimeout(() => listeners['connection_open']?.(), 0);
+          return conn;
+        },
+      };
+    }
+
+    const comp = new AmqpComponent();
+    comp.setClientFactory10(mockFactory);
+
+    const params = new URLSearchParams('protocol=1.0&jms=true');
+    const ctx = new CamelContext();
+    const ep = comp.createEndpoint('amqp://localhost:5672/orders?protocol=1.0&jms=true', '', params, ctx);
+    const producer = ep.createProducer();
+
+    const ex = makeExchange('order payload');
+    ex.in.setHeader('JMSMessageID', 'ID:order-001');
+    ex.in.setHeader('JMSCorrelationID', 'sess-abc');
+    ex.in.setHeader('JMSType', 'OrderCreated');
+
+    await producer.send(ex);
+
+    assert.equal(sent.length, 1);
+    assert.equal(sent[0].properties.message_id, 'ID:order-001');
+    assert.equal(sent[0].properties.correlation_id, 'sess-abc');
+    assert.equal(sent[0].properties.subject, 'OrderCreated');
+  });
+});
+
+// ── Amqp091Producer unit test (mock amqplib) ─────────────────────────────────
+
+describe('Amqp091Producer', () => {
+  it('sends exchange body as AMQP 0-9-1 message via mock connection', async () => {
+    const sent = [];
+
+    async function mockFactory(url) {
+      return {
+        async createChannel() {
+          return {
+            async assertQueue(q) {},
+            sendToQueue(q, content, opts) { sent.push({ q, content: content.toString(), opts }); },
+            async close() {},
+          };
+        },
+        async close() {},
+      };
+    }
+
+    const comp = new AmqpComponent();
+    comp.setClientFactory091(mockFactory);
+
+    const params = new URLSearchParams('protocol=0-9-1');
+    const ctx = new CamelContext();
+    const ep = comp.createEndpoint('amqp://localhost:5672/events?protocol=0-9-1', '', params, ctx);
+    const producer = ep.createProducer();
+
+    const ex = makeExchange('event payload');
+    await producer.send(ex);
+
+    assert.equal(sent.length, 1);
+    assert.equal(sent[0].q, 'events');
+    assert.equal(sent[0].content, 'event payload');
+  });
+});
+
+// ── Amqp10Consumer unit test (mock container — lifecycle + message dispatch) ──
+
+describe('Amqp10Consumer', () => {
+  it('delivers message to pipeline and closes cleanly on stop()', async () => {
+    const processed = [];
+
+    // Minimal mock pipeline
+    const pipeline = {
+      async run(exchange) { processed.push(exchange.in.body); },
+    };
+
+    let capturedMessageHandler = null;
+    let capturedCloseHandler = null;
+
+    function mockFactory() {
+      return {
+        connect() {
+          const listeners = {};
+          const conn = {
+            on(event, fn) {
+              listeners[event] = fn;
+              if (event === 'message') capturedMessageHandler = fn;
+              if (event === 'connection_close') capturedCloseHandler = fn;
+              return conn;
+            },
+            once(event, fn) {
+              listeners['__once_' + event] = fn;
+              if (event === 'connection_close') capturedCloseHandler = fn;
+              if (event === 'disconnected') {
+                // noop
+              }
+              return conn;
+            },
+            open_receiver(queue) { return {}; },
+            close() {
+              // Simulate broker confirming close
+              setTimeout(() => {
+                const h = listeners['__once_connection_close'] ?? listeners['connection_close'];
+                if (h) h();
+              }, 0);
+            },
+          };
+          // Emit connection_open after a tick
+          setTimeout(() => listeners['connection_open']?.(), 0);
+          return conn;
+        },
+      };
+    }
+
+    const comp = new AmqpComponent();
+    comp.setClientFactory10(mockFactory);
+
+    const params = new URLSearchParams('protocol=1.0');
+    const ctx = new CamelContext();
+    const ep = comp.createEndpoint('amqp://localhost:5672/testq?protocol=1.0', '', params, ctx);
+    const consumer = ep.createConsumer(pipeline);
+
+    await consumer.start();
+
+    // Simulate an incoming AMQP 1.0 message
+    assert.ok(capturedMessageHandler, 'message handler should be registered');
+    capturedMessageHandler({ message: { body: 'incoming message', properties: {} } });
+
+    // Give async pipeline.run() time to execute
+    await new Promise(r => setTimeout(r, 10));
+
+    assert.equal(processed.length, 1);
+    assert.equal(processed[0], 'incoming message');
+
+    await consumer.stop();
+    // Verify: context consumer cleared
+    assert.equal(ctx.getConsumer('amqp://localhost:5672/testq?protocol=1.0'), null);
+  });
+
+  it('fromAmqp10 JMS mapping applied when jmsMapping=true', async () => {
+    const exchanges = [];
+
+    const pipeline = { async run(ex) { exchanges.push(ex); } };
+    let capturedMessageHandler = null;
+
+    function mockFactory() {
+      return {
+        connect() {
+          const listeners = {};
+          const conn = {
+            on(ev, fn) {
+              listeners[ev] = fn;
+              if (ev === 'message') capturedMessageHandler = fn;
+              return conn;
+            },
+            once(ev, fn) { listeners['__once_' + ev] = fn; return conn; },
+            open_receiver() { return {}; },
+            close() {
+              setTimeout(() => {
+                const h = listeners['__once_connection_close'] ?? listeners['connection_close'];
+                if (h) h();
+              }, 0);
+            },
+          };
+          setTimeout(() => listeners['connection_open']?.(), 0);
+          return conn;
+        },
+      };
+    }
+
+    const comp = new AmqpComponent();
+    comp.setClientFactory10(mockFactory);
+
+    const params = new URLSearchParams('protocol=1.0&jms=true');
+    const ctx = new CamelContext();
+    const ep = comp.createEndpoint('amqp://localhost:5672/orders?protocol=1.0&jms=true', '', params, ctx);
+    const consumer = ep.createConsumer(pipeline);
+
+    await consumer.start();
+    capturedMessageHandler({
+      message: {
+        body: 'order data',
+        properties: { message_id: 'ID:xyz', subject: 'OrderEvent' },
+        header: {},
+      },
+    });
+
+    await new Promise(r => setTimeout(r, 10));
+
+    assert.equal(exchanges.length, 1);
+    assert.equal(exchanges[0].in.getHeader('JMSMessageID'), 'ID:xyz');
+    assert.equal(exchanges[0].in.getHeader('JMSType'), 'OrderEvent');
+
+    await consumer.stop();
+  });
+});
+
+// ── Amqp091Consumer unit test ────────────────────────────────────────────────
+
+describe('Amqp091Consumer', () => {
+  it('delivers message to pipeline and closes cleanly on stop()', async () => {
+    const processed = [];
+    const pipeline = { async run(exchange) { processed.push(exchange.in.body); } };
+
+    let capturedConsumeHandler = null;
+
+    async function mockFactory() {
+      return {
+        async createChannel() {
+          return {
+            async assertQueue() {},
+            consume(queue, handler) { capturedConsumeHandler = handler; },
+            ack() {},
+            async close() {},
+          };
+        },
+        async close() {},
+      };
+    }
+
+    const comp = new AmqpComponent();
+    comp.setClientFactory091(mockFactory);
+
+    const params = new URLSearchParams('protocol=0-9-1');
+    const ctx = new CamelContext();
+    const ep = comp.createEndpoint('amqp://localhost:5672/q091?protocol=0-9-1', '', params, ctx);
+    const consumer = ep.createConsumer(pipeline);
+
+    await consumer.start();
+
+    // Simulate incoming message
+    assert.ok(capturedConsumeHandler, 'consume handler should be registered');
+    capturedConsumeHandler({
+      content: Buffer.from('hello 0-9-1'),
+      properties: {},
+    });
+
+    await new Promise(r => setTimeout(r, 10));
+
+    assert.equal(processed.length, 1);
+    assert.equal(processed[0], 'hello 0-9-1');
+
+    await consumer.stop();
+    assert.equal(ctx.getConsumer('amqp://localhost:5672/q091?protocol=0-9-1'), null);
+  });
+});
+
+// ── Integration test (conditional on AMQP_URL) ───────────────────────────────
+
+const AMQP_URL = process.env.AMQP_URL;
+const AMQP_PROTOCOL = process.env.AMQP_PROTOCOL ?? '1.0';
+
+if (AMQP_URL) {
+  describe('AMQP integration (live broker)', () => {
+    it('round-trips a message through a live AMQP broker', async () => {
+      // Parse URL for component
+      const url = new URL(AMQP_URL);
+      const host = url.hostname;
+      const port = url.port || 5672;
+      const queue = 'camel-lite-test-' + Date.now();
+      const endpointUri = `amqp://${host}:${port}/${queue}?protocol=${AMQP_PROTOCOL}`;
+
+      const received = [];
+      const context = new CamelContext();
+      const amqp = new AmqpComponent();
+      context.addComponent('amqp', amqp);
+
+      class TestRoutes extends RouteBuilder {
+        configure(ctx) {
+          this.from(endpointUri).process((ex) => { received.push(ex.in.body); });
+        }
+      }
+
+      context.addRoutes(new TestRoutes());
+      await context.start();
+
+      // Send a message via producer
+      const params = new URLSearchParams(`protocol=${AMQP_PROTOCOL}`);
+      const endpoint = amqp.createEndpoint(endpointUri, '', params, context);
+      const producer = endpoint.createProducer();
+
+      const ex = new Exchange();
+      ex.in.body = 'integration test message';
+      await producer.send(ex);
+
+      // Wait for consumer to receive
+      await new Promise(r => setTimeout(r, 500));
+
+      await context.stop();
+
+      assert.ok(received.length >= 1, 'should have received at least one message');
+      assert.equal(received[0], 'integration test message');
+    });
+  });
+} else {
+  describe('AMQP integration (skipped — set AMQP_URL to enable)', () => {
+    it('skipped', () => { /* no-op */ });
+  });
+}