@alt-javascript/camel-lite-core 1.0.2 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alt-javascript/camel-lite-core",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "type": "module",
   "exports": {
     ".": "./src/index.js"
@@ -9,8 +9,8 @@
     "test": "node --test"
   },
   "devDependencies": {
-    "@alt-javascript/camel-lite-component-direct": "1.0.2",
-    "@alt-javascript/camel-lite-component-seda": "1.0.2"
+    "@alt-javascript/camel-lite-component-direct": "1.1.1",
+    "@alt-javascript/camel-lite-component-seda": "1.1.1"
   },
   "dependencies": {
     "@alt-javascript/common": "^3.0.7",
@@ -24,8 +24,7 @@
   },
   "author": "Craig Parravicini",
   "contributors": [
-    "Claude (Anthropic)",
-    "Apache Camel — design inspiration and pattern source"
+    "Claude (Anthropic)"
   ],
   "keywords": [
     "alt-javascript",

package/src/CamelContext.js

@@ -1,4 +1,5 @@
 import { LoggerFactory } from '@alt-javascript/logger';
+import { PollingConsumerAdapter } from './PollingConsumerAdapter.js';
 
 const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/CamelContext');
 
@@ -10,6 +11,7 @@ class CamelContext {
   #beans = new Map();
   #started = false;
   #abortController = null;
+  #pollingUris = new Set();
 
   /**
    * Register a named bean in the context.
@@ -41,6 +43,15 @@ class CamelContext {
     return Array.from(this.#beans.entries());
   }
 
+  /**
+   * Declare which consumer URIs should be wrapped with a PollingConsumerAdapter
+   * so they can be polled via ConsumerTemplate.  Must be set before start().
+   * @param {Set<string>|Iterable<string>} uriSet
+   */
+  set pollingUris(uriSet) {
+    this.#pollingUris = uriSet instanceof Set ? uriSet : new Set(uriSet);
+  }
+
   addComponent(scheme, component) {
     this.#components.set(scheme, component);
     return this;
@@ -98,9 +109,27 @@ class CamelContext {
 
       const compiledPipeline = routeDef.compile(this, { signal });
       const endpoint = component.createEndpoint(fromUri, remaining, params, this);
-      const consumer = endpoint.createConsumer(compiledPipeline);
-      this.#consumers.set(fromUri, consumer);
-      await consumer.start();
+
+      let consumerToRegister;
+      if (this.#pollingUris.has(fromUri)) {
+        // Wrap the real consumer with a PollingConsumerAdapter so ConsumerTemplate
+        // can poll it via the BufferQueue.
+        const adapter = new PollingConsumerAdapter();
+        const capPipeline = adapter.capturedPipeline;
+        const realConsumer = endpoint.createConsumer(capPipeline);
+        adapter.setConsumer(realConsumer);
+        consumerToRegister = adapter;
+      } else {
+        consumerToRegister = endpoint.createConsumer(compiledPipeline);
+      }
+
+      this.#consumers.set(fromUri, consumerToRegister);
+      await consumerToRegister.start();
+      // For polling URIs, the real consumer's start() calls registerConsumer(uri, self),
+      // which overwrites the adapter.  Re-register the adapter so getConsumer() returns it.
+      if (this.#pollingUris.has(fromUri)) {
+        this.#consumers.set(fromUri, consumerToRegister);
+      }
     }
 
     log.info('Apache Camel Lite started');

package/src/ConsumerTemplate.js

@@ -2,14 +2,14 @@ import { LoggerFactory } from '@alt-javascript/logger';
 
 const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/ConsumerTemplate');
 
-const SUPPORTED_POLL_SCHEMES = new Set(['seda']);
-
 /**
- * ConsumerTemplate — high-level API for polling messages from queue-based
- * endpoints (currently seda:) registered in a running CamelContext.
+ * ConsumerTemplate — high-level API for polling messages from endpoints
+ * registered in a running CamelContext.
  *
- * Only polling-capable endpoints are supported. Push-model endpoints like
- * direct: do not expose a dequeuable queue and will throw a clear error.
+ * Any consumer that exposes a `poll(timeoutMs)` method is supported.
+ * For push-model endpoints (direct:, timer:, etc.) you must declare the URI
+ * in `ctx.pollingUris` before starting the context so CamelContext wraps it
+ * with a PollingConsumerAdapter.
  *
  * Usage:
  *   const ct = new ConsumerTemplate(context);
@@ -32,13 +32,8 @@ class ConsumerTemplate {
    * @returns {Promise<Exchange|null>}
    */
   async receive(uri, timeoutMs = 5000) {
-    const scheme = this.#scheme(uri);
-    if (!SUPPORTED_POLL_SCHEMES.has(scheme)) {
-      throw new Error(
-        `ConsumerTemplate does not support polling from '${scheme}:'. ` +
-        `Supported schemes: ${[...SUPPORTED_POLL_SCHEMES].join(', ')}`
-      );
-    }
+    // Validate URI format
+    this.#scheme(uri);
 
     log.info(`ConsumerTemplate polling from ${uri}`);
 
@@ -47,6 +42,12 @@ class ConsumerTemplate {
       throw new Error(`ConsumerTemplate: no consumer registered for '${uri}' — is the context started?`);
     }
 
+    if (typeof consumer.poll !== 'function') {
+      throw new Error(
+        `ConsumerTemplate: consumer for '${uri}' does not support polling — wrap it with PollingConsumerAdapter`
+      );
+    }
+
     return consumer.poll(timeoutMs);
   }
 

package/src/PollingConsumerAdapter.js

@@ -0,0 +1,142 @@
+import { LoggerFactory } from '@alt-javascript/logger';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/PollingConsumerAdapter');
+
+/**
+ * Inline async queue — same mechanics as SedaQueue without the SedaQueueFullError
+ * dependency.  Used internally by PollingConsumerAdapter.
+ */
+class BufferQueue {
+  #items = [];
+  #waiters = [];
+  #closed = false;
+
+  enqueue(item) {
+    if (this.#closed) return; // silently drop after close
+    if (this.#waiters.length > 0) {
+      this.#waiters.shift().resolve(item);
+    } else {
+      this.#items.push(item);
+    }
+  }
+
+  dequeue() {
+    if (this.#items.length > 0) {
+      return Promise.resolve(this.#items.shift());
+    }
+    if (this.#closed) {
+      return Promise.resolve(null);
+    }
+    return new Promise(resolve => this.#waiters.push({ resolve }));
+  }
+
+  close() {
+    this.#closed = true;
+    for (const waiter of this.#waiters) {
+      waiter.resolve(null);
+    }
+    this.#waiters = [];
+  }
+
+  get closed() {
+    return this.#closed;
+  }
+}
+
+/**
+ * PollingConsumerAdapter — wraps any push-model Consumer (timer:, direct:, etc.)
+ * and exposes a `poll(timeoutMs)` method compatible with ConsumerTemplate.
+ *
+ * The adapter injects a "capture pipeline" into the real consumer at construction
+ * time.  Whenever the real consumer fires an exchange into that pipeline, the
+ * adapter enqueues it in an internal BufferQueue.  Callers can then drain the
+ * queue via `poll()`.
+ *
+ * Usage (handled automatically by CamelContext when pollingUris is set):
+ *
+ *   const adapter = new PollingConsumerAdapter();
+ *   const realConsumer = endpoint.createConsumer(adapter.capturedPipeline);
+ *   adapter.setConsumer(realConsumer);
+ *   await adapter.start();
+ *   const exchange = await adapter.poll(5000);
+ *   await adapter.stop();
+ */
+class PollingConsumerAdapter {
+  #consumer = null;
+  #queue = new BufferQueue();
+
+  /**
+   * The fake pipeline that the real consumer fires exchanges into.
+   * Returns a plain object with a `run(exchange)` method so it satisfies
+   * the Pipeline interface expected by all consumers.
+   */
+  get capturedPipeline() {
+    return {
+      run: (exchange) => {
+        log.debug(`PollingConsumerAdapter captured exchange ${exchange?.in?.messageId}`);
+        this.#queue.enqueue(exchange);
+        return Promise.resolve(exchange);
+      },
+    };
+  }
+
+  /**
+   * Inject the real consumer after creation (two-phase init).
+   * @param {Consumer} consumer
+   */
+  setConsumer(consumer) {
+    this.#consumer = consumer;
+  }
+
+  /**
+   * Called by DirectProducer when it looks up the consumer by URI and calls
+   * process() on it directly.  Routes the exchange through the capture queue
+   * so ConsumerTemplate can drain it.
+   * @param {Exchange} exchange
+   * @returns {Promise<Exchange>}
+   */
+  async process(exchange) {
+    log.debug(`PollingConsumerAdapter.process() captured exchange ${exchange?.in?.messageId}`);
+    this.#queue.enqueue(exchange);
+    return exchange;
+  }
+
+  /**
+   * Start the real consumer.
+   */
+  async start() {
+    if (this.#consumer) {
+      await this.#consumer.start();
+    }
+  }
+
+  /**
+   * Stop the real consumer and close the buffer queue.
+   */
+  async stop() {
+    if (this.#consumer) {
+      await this.#consumer.stop();
+    }
+    this.#queue.close();
+  }
+
+  /**
+   * Poll for the next exchange, waiting at most timeoutMs milliseconds.
+   * Returns the Exchange or null on timeout.
+   * @param {number} [timeoutMs=5000]
+   * @returns {Promise<Exchange|null>}
+   */
+  async poll(timeoutMs = 5000) {
+    let timer;
+    const timeout = new Promise(resolve => {
+      timer = setTimeout(() => resolve(null), timeoutMs);
+    });
+    log.debug(`PollingConsumerAdapter polling (timeout=${timeoutMs}ms)`);
+    const item = await Promise.race([this.#queue.dequeue(), timeout]);
+    clearTimeout(timer);
+    return item;
+  }
+}
+
+export { PollingConsumerAdapter };
+export default PollingConsumerAdapter;

package/src/index.js

@@ -15,3 +15,4 @@ export { AggregationStrategies } from './AggregationStrategies.js';
 export { RouteLoader } from './RouteLoader.js';
 export { ProducerTemplate } from './ProducerTemplate.js';
 export { ConsumerTemplate } from './ConsumerTemplate.js';
+export { PollingConsumerAdapter } from './PollingConsumerAdapter.js';

package/test/ConsumerTemplate.test.js

@@ -1,8 +1,9 @@
 import { describe, it, before, after } from 'node:test';
 import assert from 'node:assert/strict';
-import { CamelContext, ConsumerTemplate, ProducerTemplate } from '../src/index.js';
+import { CamelContext, ConsumerTemplate, ProducerTemplate, PollingConsumerAdapter } from '../src/index.js';
 import { DirectComponent } from '@alt-javascript/camel-lite-component-direct';
 import { SedaComponent } from '@alt-javascript/camel-lite-component-seda';
+import { TimerComponent } from '@alt-javascript/camel-lite-component-timer';
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -26,13 +27,18 @@ describe('ConsumerTemplate: constructor', () => {
 });
 
 describe('ConsumerTemplate: unsupported schemes', () => {
-  it('throws for direct: scheme', async () => {
+  it('throws for direct: scheme without pollingUris wrapper', async () => {
+    // direct: consumer has no poll() — expect "does not support polling" error
     const ctx = makeContext();
-    await ctx.start();
+    const { RouteBuilder } = await import('../src/RouteBuilder.js');
+    const builder = new RouteBuilder();
+    builder.from('direct:foo').process(ex => ex);
+    ctx.addRoutes(builder);
+    await ctx.start();   // no pollingUris set → raw DirectConsumer registered
     const ct = new ConsumerTemplate(ctx);
     await assert.rejects(
       () => ct.receive('direct:foo'),
-      /does not support polling from 'direct:'/
+      /does not support polling/
     );
     await ctx.stop();
   });
@@ -144,3 +150,69 @@ describe('ConsumerTemplate: poll without competing route worker', () => {
     assert.equal(exchange, null);
   });
 });
+
+// ---------------------------------------------------------------------------
+// PollingConsumerAdapter: wrapping a timer: consumer
+// ---------------------------------------------------------------------------
+
+describe('ConsumerTemplate: PollingConsumerAdapter with timer:', () => {
+  let ctx;
+
+  before(async () => {
+    ctx = new CamelContext();
+    ctx.addComponent('direct', new DirectComponent());
+    ctx.addComponent('seda', new SedaComponent());
+    ctx.addComponent('timer', new TimerComponent());
+
+    const { RouteBuilder } = await import('../src/RouteBuilder.js');
+    const builder = new RouteBuilder();
+    // A timer route that fires 3 times with 50 ms period.
+    builder.from('timer:tick?period=50&repeatCount=3').process(ex => ex);
+    ctx.addRoutes(builder);
+
+    // Declare the timer URI as a polling URI before start.
+    ctx.pollingUris = new Set(['timer:tick?period=50&repeatCount=3']);
+    await ctx.start();
+  });
+
+  after(async () => {
+    await ctx.stop();
+  });
+
+  it('poll() returns a non-null Exchange with CamelTimerName header', async () => {
+    const ct = new ConsumerTemplate(ctx);
+    const exchange = await ct.receive('timer:tick?period=50&repeatCount=3', 500);
+    assert.notEqual(exchange, null, 'expected an Exchange, got null (timeout)');
+    assert.equal(
+      exchange.in.getHeader('CamelTimerName'),
+      'tick',
+      'expected CamelTimerName header to be "tick"'
+    );
+  });
+
+  it('PollingConsumerAdapter is exported from camel-lite-core index', () => {
+    assert.ok(typeof PollingConsumerAdapter === 'function', 'PollingConsumerAdapter should be a class/function');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// PollingConsumerAdapter: direct without pollingUris throws
+// ---------------------------------------------------------------------------
+
+describe('ConsumerTemplate: raw direct: consumer throws does not support polling', () => {
+  it('direct: consumer without pollingUris wrapper throws the expected error', async () => {
+    const ctx = makeContext();
+    const { RouteBuilder } = await import('../src/RouteBuilder.js');
+    const builder = new RouteBuilder();
+    builder.from('direct:bar').process(ex => ex);
+    ctx.addRoutes(builder);
+    // No pollingUris — DirectConsumer has no poll() method
+    await ctx.start();
+    const ct = new ConsumerTemplate(ctx);
+    await assert.rejects(
+      () => ct.receive('direct:bar', 100),
+      /does not support polling/
+    );
+    await ctx.stop();
+  });
+});