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

package/README.md

@@ -0,0 +1,53 @@
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## What
+
+Structured logging via [`@alt-javascript/logger`](https://www.npmjs.com/package/@alt-javascript/logger). Sends the exchange body (stringified if not already a string) to the named logger at the configured level. Producer-only — no consumer.
+
+## Install
+
+```sh
+npm install camel-lite-component-log @alt-javascript/logger @alt-javascript/config @alt-javascript/common
+```
+
+## URI Syntax
+
+```
+log:loggerName[?level=info]
+```
+
+| Segment / Parameter | Default | Description |
+|---------------------|---------|-------------|
+| `loggerName`        | *(required)* | Logger category name (case-preserved). Passed directly to `LoggerFactory.getLogger`. |
+| `level`             | `info`  | Log level: `trace`, `debug`, `info`, `warn`, or `error`. |
+
+## Usage
+
+```js
+import { CamelContext } from 'camel-lite-core';
+import { LogComponent } from 'camel-lite-component-log';
+
+const context = new CamelContext();
+context.addComponent('log', new LogComponent());
+
+context.addRoutes({
+  configure(ctx) {
+    ctx.from('direct:ingest')
+      .to('log:com.example.ingest?level=debug')
+      .process(exchange => {
+        // continue processing after log
+      });
+  }
+});
+
+await context.start();
+
+const template = context.createProducerTemplate();
+await template.sendBody('direct:ingest', { id: 1, value: 'hello' });
+
+await context.stop();
+```
+
+## See Also
+
+[camel-lite — root README](../../README.md)

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@alt-javascript/camel-lite-component-log",
+  "version": "1.0.2",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "dependencies": {
+    "@alt-javascript/common": "^3.0.7",
+    "@alt-javascript/config": "^3.0.7",
+    "@alt-javascript/logger": "^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",
+    "log",
+    "logging",
+    "component"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/src/LogComponent.js

@@ -0,0 +1,11 @@
+import { Component } from '@alt-javascript/camel-lite-core';
+import LogEndpoint from './LogEndpoint.js';
+
+class LogComponent extends Component {
+  createEndpoint(uri, remaining, parameters, context) {
+    return new LogEndpoint(uri);
+  }
+}
+
+export { LogComponent };
+export default LogComponent;

package/src/LogEndpoint.js

@@ -0,0 +1,65 @@
+import { Endpoint } from '@alt-javascript/camel-lite-core';
+import LogProducer from './LogProducer.js';
+
+class LogEndpoint extends Endpoint {
+  #uri;
+  #level;
+  #showBody;
+  #showHeaders;
+  #loggerName;
+
+  constructor(uri) {
+    super();
+    this.#uri = uri;
+
+    // Strip scheme: 'log:output?level=info' → 'output?level=info'
+    const remaining = uri.slice(uri.indexOf(':') + 1);
+
+    // Split name from query string manually to preserve case
+    const qIdx = remaining.indexOf('?');
+    const namePart = qIdx >= 0 ? remaining.slice(0, qIdx) : remaining;
+    const queryPart = qIdx >= 0 ? remaining.slice(qIdx + 1) : '';
+    const params = new URLSearchParams(queryPart);
+
+    this.#loggerName = namePart || 'log';
+    this.#level = (params.get('level') ?? 'info').toLowerCase();
+    this.#showBody = params.get('showBody') !== 'false';
+    this.#showHeaders = params.get('showHeaders') === 'true';
+  }
+
+  get uri() {
+    return this.#uri;
+  }
+
+  get loggerName() {
+    return this.#loggerName;
+  }
+
+  get level() {
+    return this.#level;
+  }
+
+  get showBody() {
+    return this.#showBody;
+  }
+
+  get showHeaders() {
+    return this.#showHeaders;
+  }
+
+  createProducer() {
+    return new LogProducer({
+      level: this.#level,
+      showBody: this.#showBody,
+      showHeaders: this.#showHeaders,
+      loggerName: this.#loggerName,
+    });
+  }
+
+  createConsumer() {
+    throw new Error('log: component is producer-only');
+  }
+}
+
+export { LogEndpoint };
+export default LogEndpoint;

package/src/LogProducer.js

@@ -0,0 +1,58 @@
+import { Producer } from '@alt-javascript/camel-lite-core';
+import { LoggerFactory } from '@alt-javascript/logger';
+
+const VALID_LEVELS = new Set(['info', 'warn', 'error', 'debug']);
+
+class LogProducer extends Producer {
+  #level;
+  #showBody;
+  #showHeaders;
+  #loggerName;
+  #logger;
+
+  constructor({ level, showBody, showHeaders, loggerName } = {}) {
+    super();
+    this.#level = VALID_LEVELS.has(level) ? level : 'info';
+    this.#showBody = showBody !== false;
+    this.#showHeaders = showHeaders === true;
+    this.#loggerName = loggerName || 'log';
+    this.#logger = LoggerFactory.getLogger(this.#loggerName);
+  }
+
+  get level() {
+    return this.#level;
+  }
+
+  get showBody() {
+    return this.#showBody;
+  }
+
+  get showHeaders() {
+    return this.#showHeaders;
+  }
+
+  get loggerName() {
+    return this.#loggerName;
+  }
+
+  async send(exchange) {
+    const parts = [this.#loggerName];
+
+    if (this.#showBody) {
+      parts.push('body: ' + JSON.stringify(exchange.in.body));
+    }
+
+    if (this.#showHeaders && exchange.in.headers) {
+      const headers = exchange.in.headers instanceof Map
+        ? Object.fromEntries(exchange.in.headers)
+        : exchange.in.headers;
+      parts.push('headers: ' + JSON.stringify(headers));
+    }
+
+    const message = parts.join(' ');
+    this.#logger[this.#level](message);
+  }
+}
+
+export { LogProducer };
+export default LogProducer;

package/src/index.js

@@ -0,0 +1,6 @@
+export { LogComponent, default as LogComponentDefault } from './LogComponent.js';
+export { LogEndpoint, default as LogEndpointDefault } from './LogEndpoint.js';
+export { LogProducer, default as LogProducerDefault } from './LogProducer.js';
+
+import LogComponent from './LogComponent.js';
+export default LogComponent;

package/test/integration.test.js

@@ -0,0 +1,80 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { CamelContext, Exchange, RouteDefinition } from '@alt-javascript/camel-lite-core';
+import { DirectComponent } from '@alt-javascript/camel-lite-component-direct';
+import { LogComponent } from '@alt-javascript/camel-lite-component-log';
+
+describe('End-to-end integration: direct: + log: components', () => {
+  it('routes an exchange through two chained direct: routes ending at log:', async () => {
+    const context = new CamelContext();
+    context.addComponent('direct', new DirectComponent());
+    context.addComponent('log', new LogComponent());
+
+    const routeA = new RouteDefinition('direct:entry');
+    routeA.process((exchange) => { exchange.in.body = 'hello'; });
+    routeA.to('direct:chain');
+
+    const routeB = new RouteDefinition('direct:chain');
+    routeB.process((exchange) => { exchange.in.body = exchange.in.body + ' world'; });
+    routeB.to('log:output?level=info&showBody=true');
+
+    context.addRoutes({ configure() {}, getRoutes() { return [routeA, routeB]; } });
+
+    await context.start();
+    try {
+      const exchange = new Exchange();
+      const entryConsumer = context.getConsumer('direct:entry');
+      assert.ok(entryConsumer, 'DirectConsumer for direct:entry must be registered after start()');
+
+      await entryConsumer.process(exchange);
+
+      assert.equal(exchange.in.body, 'hello world',
+        `Expected 'hello world', got: ${JSON.stringify(exchange.in.body)}`);
+      assert.equal(exchange.exception, null, 'exchange.exception should be null');
+    } finally {
+      await context.stop();
+    }
+  });
+
+  it('context.stop() deregisters all consumers', async () => {
+    const context = new CamelContext();
+    context.addComponent('direct', new DirectComponent());
+    context.addComponent('log', new LogComponent());
+
+    const routeA = new RouteDefinition('direct:entry2');
+    routeA.process((exchange) => { exchange.in.body = 'test'; });
+    routeA.to('log:sink?showBody=false');
+
+    context.addRoutes({ configure() {}, getRoutes() { return [routeA]; } });
+
+    await context.start();
+    assert.ok(context.getConsumer('direct:entry2'), 'consumer registered after start');
+
+    await context.stop();
+    const consumer = context.getConsumer('direct:entry2');
+    assert.ok(!consumer, 'consumer should be deregistered after stop');
+  });
+
+  it('standalone log producer route works end-to-end — exchange state correct', async () => {
+    const context = new CamelContext();
+    context.addComponent('direct', new DirectComponent());
+    context.addComponent('log', new LogComponent());
+
+    const route = new RouteDefinition('direct:standalone');
+    route.process((exchange) => { exchange.in.body = 'standalone message'; });
+    route.to('log:standalone?level=info&showBody=true');
+
+    context.addRoutes({ configure() {}, getRoutes() { return [route]; } });
+
+    await context.start();
+    try {
+      const exchange = new Exchange();
+      await context.getConsumer('direct:standalone').process(exchange);
+
+      assert.equal(exchange.in.body, 'standalone message');
+      assert.equal(exchange.exception, null);
+    } finally {
+      await context.stop();
+    }
+  });
+});

package/test/log.test.js

@@ -0,0 +1,109 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { Exchange } from '@alt-javascript/camel-lite-core';
+import { LogComponent, LogEndpoint, LogProducer } from '@alt-javascript/camel-lite-component-log';
+
+describe('LogComponent', () => {
+  it('can be constructed', () => {
+    const lc = new LogComponent();
+    assert.ok(lc instanceof LogComponent);
+  });
+
+  it('createEndpoint returns LogEndpoint', () => {
+    const lc = new LogComponent();
+    const ep = lc.createEndpoint('log:myLogger', 'myLogger', {}, null);
+    assert.ok(ep instanceof LogEndpoint);
+    assert.equal(ep.uri, 'log:myLogger');
+  });
+});
+
+describe('LogEndpoint', () => {
+  it('createProducer returns LogProducer', () => {
+    const ep = new LogEndpoint('log:test');
+    const producer = ep.createProducer();
+    assert.ok(producer instanceof LogProducer);
+  });
+
+  it('createConsumer throws', () => {
+    const ep = new LogEndpoint('log:test');
+    assert.throws(() => ep.createConsumer(), { message: 'log: component is producer-only' });
+  });
+
+  it('parses URI: loggerName extracted correctly — defaults to info level', () => {
+    const ep = new LogEndpoint('log:myLogger');
+    assert.equal(ep.loggerName, 'myLogger');
+    assert.equal(ep.level, 'info');
+    assert.equal(ep.showBody, true);
+    assert.equal(ep.showHeaders, false);
+  });
+
+  it('parses URI: log:myLogger?level=info&showBody=false', () => {
+    const ep = new LogEndpoint('log:myLogger?level=info&showBody=false');
+    assert.equal(ep.loggerName, 'myLogger');
+    assert.equal(ep.level, 'info');
+    assert.equal(ep.showBody, false);
+    assert.equal(ep.showHeaders, false);
+  });
+
+  it('parses URI: log:output?level=warn&showBody=true&showHeaders=true', () => {
+    const ep = new LogEndpoint('log:output?level=warn&showBody=true&showHeaders=true');
+    assert.equal(ep.loggerName, 'output');
+    assert.equal(ep.level, 'warn');
+    assert.equal(ep.showBody, true);
+    assert.equal(ep.showHeaders, true);
+  });
+});
+
+describe('LogProducer', () => {
+  it('send() completes without error for a body exchange', async () => {
+    const producer = new LogProducer({ level: 'info', showBody: true, loggerName: 'test' });
+    const exchange = new Exchange();
+    exchange.in.body = { hello: 'world' };
+    await assert.doesNotReject(() => producer.send(exchange));
+  });
+
+  it('send() completes without error for debug level', async () => {
+    const producer = new LogProducer({ level: 'debug', showBody: true, loggerName: 'test' });
+    const exchange = new Exchange();
+    exchange.in.body = 'debug payload';
+    await assert.doesNotReject(() => producer.send(exchange));
+  });
+
+  it('send() completes without error when showBody=false', async () => {
+    const producer = new LogProducer({ level: 'info', showBody: false, loggerName: 'test' });
+    const exchange = new Exchange();
+    exchange.in.body = 'secret';
+    await assert.doesNotReject(() => producer.send(exchange));
+  });
+
+  it('send() completes without error when showHeaders=true', async () => {
+    const producer = new LogProducer({ level: 'info', showBody: false, showHeaders: true, loggerName: 'test' });
+    const exchange = new Exchange();
+    exchange.in.setHeader('x-trace', 'abc123');
+    await assert.doesNotReject(() => producer.send(exchange));
+  });
+
+  it('unknown level falls back to info', () => {
+    const producer = new LogProducer({ level: 'trace', showBody: true, loggerName: 'test' });
+    assert.equal(producer.level, 'info', 'unknown level should fall back to info');
+  });
+
+  it('log level alias falls back to info', () => {
+    const producer = new LogProducer({ level: 'log', showBody: true, loggerName: 'test' });
+    assert.equal(producer.level, 'info', 'log level should alias to info');
+  });
+
+  it('loggerName is used as the logger category', () => {
+    const producer = new LogProducer({ level: 'info', showBody: true, loggerName: 'myRoute' });
+    assert.equal(producer.loggerName, 'myRoute');
+  });
+
+  it('exchange is not mutated by send()', async () => {
+    const producer = new LogProducer({ level: 'info', showBody: true, loggerName: 'test' });
+    const exchange = new Exchange();
+    exchange.in.body = 'unchanged';
+    await producer.send(exchange);
+    assert.equal(exchange.in.body, 'unchanged');
+    assert.equal(exchange.exception, null);
+  });
+});