@alt-javascript/camel-lite-core 1.0.2

package/src/Pipeline.js

@@ -0,0 +1,96 @@
+import { LoggerFactory } from '@alt-javascript/logger';
+import { CamelFilterStopException } from './errors/CamelFilterStopException.js';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/Pipeline');
+
+class Pipeline {
+  #steps;
+  #clauses;
+  #maxAttempts;
+  #redeliveryDelay;
+  #signal;
+
+  constructor(steps = [], options = {}) {
+    this.#steps = steps;
+    this.#clauses = options.clauses ?? [];
+    this.#maxAttempts = options.maxAttempts ?? 0;
+    this.#redeliveryDelay = options.redeliveryDelay ?? 0;
+    this.#signal = options.signal ?? null;
+  }
+
+  #sleep(ms) {
+    const signal = this.#signal;
+    if (signal && signal.aborted) {
+      log.debug('Redelivery sleep cancelled (signal already aborted)');
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const timer = setTimeout(resolve, ms);
+      if (signal) {
+        const onAbort = () => {
+          clearTimeout(timer);
+          log.debug('Redelivery sleep cancelled');
+          resolve();
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+      }
+    });
+  }
+
+  async run(exchange) {
+    for (const step of this.#steps) {
+      const totalAttempts = this.#maxAttempts + 1;
+      let attempt = 0;
+      let lastErr;
+      let succeeded = false;
+
+      while (attempt < totalAttempts) {
+        const prevOutBody = exchange.out.body;
+        try {
+          await step(exchange);
+          // Out→in promotion: if out.body was set (or changed), promote it to in
+          if (exchange.out.body !== null && exchange.out.body !== prevOutBody) {
+            exchange.in.body = exchange.out.body;
+            // Copy out headers to in
+            for (const [key, value] of exchange.out.headers) {
+              exchange.in.setHeader(key, value);
+            }
+            // Reset out
+            exchange.out.body = null;
+            exchange.out.headers.clear();
+          }
+          log.debug(`Step completed for exchange ${exchange.in.messageId}`);
+          succeeded = true;
+          break;
+        } catch (err) {
+          if (err instanceof CamelFilterStopException) {
+            // Clean stop — filter() or aggregate() held this exchange
+            log.debug(`Exchange ${exchange.in.messageId} stopped cleanly: ${err.message}`);
+            return;
+          }
+          lastErr = err;
+          attempt++;
+          if (attempt < totalAttempts && this.#redeliveryDelay > 0) {
+            await this.#sleep(this.#redeliveryDelay);
+          }
+        }
+      }
+
+      if (!succeeded) {
+        log.error(`Error processing exchange ${exchange.in.messageId}: ${lastErr.message}`);
+        exchange.exception = lastErr;
+        const clause = this.#clauses.find(c => lastErr instanceof c.errorClass);
+        if (clause) {
+          await clause.processor(exchange);
+          if (clause.handled === true) {
+            exchange.exception = null;
+          }
+        }
+        return;
+      }
+    }
+  }
+}
+
+export { Pipeline };
+export default Pipeline;

package/src/ProcessorNormalizer.js

@@ -0,0 +1,14 @@
+import CamelError from './errors/CamelError.js';
+
+function normalize(p) {
+  if (typeof p === 'function') {
+    return p;
+  }
+  if (p !== null && typeof p === 'object' && typeof p.process === 'function') {
+    return (exchange) => p.process(exchange);
+  }
+  throw new CamelError('Invalid processor: must be a function or object with a process() method');
+}
+
+export { normalize };
+export default { normalize };

package/src/ProducerTemplate.js

@@ -0,0 +1,98 @@
+import { LoggerFactory } from '@alt-javascript/logger';
+import { Exchange } from './Exchange.js';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/ProducerTemplate');
+
+/**
+ * ProducerTemplate — high-level API for sending messages to any endpoint
+ * registered in a running CamelContext.
+ *
+ * Usage:
+ *   const pt = new ProducerTemplate(context);
+ *   const exchange = await pt.sendBody('direct:myRoute', 'hello');
+ *   const result   = await pt.requestBody('direct:myRoute', 'hello');
+ */
+class ProducerTemplate {
+  #context;
+
+  constructor(context) {
+    if (!context) throw new Error('ProducerTemplate requires a CamelContext');
+    this.#context = context;
+  }
+
+  /**
+   * Low-level: resolve a producer for the given URI and send the exchange as-is.
+   * Returns the exchange after send completes.
+   * @param {string} uri
+   * @param {Exchange} exchange
+   * @returns {Promise<Exchange>}
+   */
+  async send(uri, exchange) {
+    const producer = this.#resolveProducer(uri);
+    log.info(`ProducerTemplate sending to ${uri}`);
+    log.debug(`ProducerTemplate exchange id=${exchange.in.messageId}`);
+    await producer.send(exchange);
+    return exchange;
+  }
+
+  /**
+   * InOnly send — creates an exchange with the given body and headers and sends it.
+   * Returns the exchange after completion (check exchange.exception for errors).
+   * @param {string} uri
+   * @param {*} body
+   * @param {Object} [headers={}]
+   * @returns {Promise<Exchange>}
+   */
+  async sendBody(uri, body, headers = {}) {
+    const exchange = this.#makeExchange('InOnly', body, headers);
+    return this.send(uri, exchange);
+  }
+
+  /**
+   * InOut request-reply — creates an exchange with the given body and sends it.
+   * Returns exchange.out.body if set, otherwise exchange.in.body.
+   * @param {string} uri
+   * @param {*} body
+   * @param {Object} [headers={}]
+   * @returns {Promise<*>}
+   */
+  async requestBody(uri, body, headers = {}) {
+    const exchange = this.#makeExchange('InOut', body, headers);
+    await this.send(uri, exchange);
+    // Prefer out body; fall back to in body (in-place mutation pattern)
+    const outBody = exchange.out.body;
+    return (outBody !== null && outBody !== undefined) ? outBody : exchange.in.body;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+
+  #makeExchange(pattern, body, headers) {
+    const exchange = new Exchange(pattern);
+    exchange.in.body = body;
+    for (const [k, v] of Object.entries(headers)) {
+      exchange.in.setHeader(k, v);
+    }
+    return exchange;
+  }
+
+  #resolveProducer(uri) {
+    const colonIdx = uri.indexOf(':');
+    if (colonIdx < 0) throw new Error(`ProducerTemplate: invalid URI (no scheme): ${uri}`);
+    const scheme = uri.slice(0, colonIdx);
+    const rest = uri.slice(colonIdx + 1);
+    const qIdx = rest.indexOf('?');
+    const remaining = qIdx >= 0 ? rest.slice(0, qIdx) : rest;
+    const params = qIdx >= 0 ? new URLSearchParams(rest.slice(qIdx + 1)) : new URLSearchParams();
+
+    const component = this.#context.getComponent(scheme);
+    if (!component) throw new Error(`ProducerTemplate: no component registered for scheme '${scheme}'`);
+
+    const endpoint = component.createEndpoint(uri, remaining, params, this.#context);
+    return endpoint.createProducer();
+  }
+}
+
+export { ProducerTemplate };
+export default ProducerTemplate;

package/src/RouteBuilder.js

@@ -0,0 +1,21 @@
+import { RouteDefinition } from './RouteDefinition.js';
+
+class RouteBuilder {
+  #routes = [];
+
+  from(uri) {
+    const routeDef = new RouteDefinition(uri);
+    this.#routes.push(routeDef);
+    return routeDef;
+  }
+
+  getRoutes() {
+    return [...this.#routes];
+  }
+
+  // Default no-op; subclasses override to define routes using this.from(...)
+  configure(context) {} // eslint-disable-line no-unused-vars
+}
+
+export { RouteBuilder };
+export default RouteBuilder;