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

package/README.md

@@ -0,0 +1,57 @@
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## What
+
+Synchronous in-process routing between routes. `direct:` delivers exchanges immediately in the calling thread — zero queue, zero latency. Cycle detection is built in; circular routes throw a `CamelError` at dispatch time.
+
+## Install
+
+```sh
+npm install camel-lite-component-direct
+```
+
+## URI Syntax
+
+```
+direct:name
+```
+
+| Segment | Description |
+|---------|-------------|
+| `name`  | Route name (case-sensitive). Must match the `from('direct:name')` of the target route. |
+
+No query parameters.
+
+## Usage
+
+```js
+import { CamelContext } from 'camel-lite-core';
+import { DirectComponent } from 'camel-lite-component-direct';
+
+const context = new CamelContext();
+context.addComponent('direct', new DirectComponent());
+
+context.addRoutes({
+  configure(ctx) {
+    ctx.from('direct:greet')
+      .process(exchange => {
+        exchange.in.body = `Hello, ${exchange.in.body}!`;
+      });
+
+    ctx.from('direct:start')
+      .to('direct:greet');
+  }
+});
+
+await context.start();
+
+const template = context.createProducerTemplate();
+const exchange = await template.send('direct:start', ex => { ex.in.body = 'World'; });
+console.log(exchange.in.body); // Hello, World!
+
+await context.stop();
+```
+
+## See Also
+
+[camel-lite — root README](../../README.md)

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@alt-javascript/camel-lite-component-direct",
+  "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",
+    "direct",
+    "routing",
+    "component"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/src/DirectComponent.js

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

package/src/DirectConsumer.js

@@ -0,0 +1,33 @@
+import { Consumer } from '@alt-javascript/camel-lite-core';
+
+class DirectConsumer extends Consumer {
+  #uri;
+  #context;
+  #pipeline;
+
+  constructor(uri, context, pipeline) {
+    super();
+    this.#uri = uri;
+    this.#context = context;
+    this.#pipeline = pipeline;
+  }
+
+  get uri() {
+    return this.#uri;
+  }
+
+  async start() {
+    this.#context.registerConsumer(this.#uri, this);
+  }
+
+  async stop() {
+    this.#context.registerConsumer(this.#uri, null);
+  }
+
+  async process(exchange) {
+    return this.#pipeline.run(exchange);
+  }
+}
+
+export { DirectConsumer };
+export default DirectConsumer;

package/src/DirectEndpoint.js

@@ -0,0 +1,29 @@
+import { Endpoint } from '@alt-javascript/camel-lite-core';
+import DirectProducer from './DirectProducer.js';
+import DirectConsumer from './DirectConsumer.js';
+
+class DirectEndpoint extends Endpoint {
+  #uri;
+  #context;
+
+  constructor(uri, context) {
+    super();
+    this.#uri = uri;
+    this.#context = context;
+  }
+
+  get uri() {
+    return this.#uri;
+  }
+
+  createProducer() {
+    return new DirectProducer(this.#uri, this.#context);
+  }
+
+  createConsumer(pipeline) {
+    return new DirectConsumer(this.#uri, this.#context, pipeline);
+  }
+}
+
+export { DirectEndpoint };
+export default DirectEndpoint;

package/src/DirectProducer.js

@@ -0,0 +1,51 @@
+import { Producer } from '@alt-javascript/camel-lite-core';
+import { CycleDetectedError } from '@alt-javascript/camel-lite-core';
+import { LoggerFactory } from '@alt-javascript/logger';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/DirectProducer');
+
+const STACK_KEY = 'camel.directStack';
+
+class DirectProducer extends Producer {
+  #uri;
+  #context;
+
+  constructor(uri, context) {
+    super();
+    this.#uri = uri;
+    this.#context = context;
+  }
+
+  get uri() {
+    return this.#uri;
+  }
+
+  async send(exchange) {
+    const stack = exchange.getProperty(STACK_KEY) || [];
+
+    if (stack.includes(this.#uri)) {
+      log.error(`Cycle detected sending to: ${this.#uri}`);
+      throw new CycleDetectedError(this.#uri);
+    }
+
+    log.debug(`Dispatching exchange to: ${this.#uri}`);
+
+    const newStack = [...stack, this.#uri];
+    exchange.setProperty(STACK_KEY, newStack);
+
+    const consumer = this.#context.getConsumer(this.#uri);
+    if (!consumer) {
+      exchange.setProperty(STACK_KEY, stack);
+      throw new Error('No consumer registered for: ' + this.#uri);
+    }
+
+    try {
+      await consumer.process(exchange);
+    } finally {
+      exchange.setProperty(STACK_KEY, stack);
+    }
+  }
+}
+
+export { DirectProducer };
+export default DirectProducer;

package/src/index.js

@@ -0,0 +1,7 @@
+export { DirectComponent } from './DirectComponent.js';
+export { DirectEndpoint } from './DirectEndpoint.js';
+export { DirectProducer } from './DirectProducer.js';
+export { DirectConsumer } from './DirectConsumer.js';
+
+import DirectComponent from './DirectComponent.js';
+export default DirectComponent;

package/test/direct.test.js

@@ -0,0 +1,144 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { Exchange, CamelContext, Pipeline, CycleDetectedError } from '@alt-javascript/camel-lite-core';
+import { DirectComponent, DirectEndpoint, DirectProducer, DirectConsumer } from '@alt-javascript/camel-lite-component-direct';
+
+// Helper: build a minimal pipeline that sets a property on the exchange
+function mutatingPipeline(key, value) {
+  return new Pipeline([
+    async (exchange) => {
+      exchange.setProperty(key, value);
+    },
+  ]);
+}
+
+describe('DirectComponent', () => {
+  it('can be constructed', () => {
+    const dc = new DirectComponent();
+    assert.ok(dc instanceof DirectComponent);
+  });
+
+  it('createEndpoint returns DirectEndpoint', () => {
+    const dc = new DirectComponent();
+    const ctx = new CamelContext();
+    const ep = dc.createEndpoint('direct:foo', 'foo', {}, ctx);
+    assert.ok(ep instanceof DirectEndpoint);
+    assert.equal(ep.uri, 'direct:foo');
+  });
+});
+
+describe('DirectEndpoint', () => {
+  it('createProducer returns DirectProducer', () => {
+    const ctx = new CamelContext();
+    const ep = new DirectEndpoint('direct:foo', ctx);
+    const producer = ep.createProducer();
+    assert.ok(producer instanceof DirectProducer);
+    assert.equal(producer.uri, 'direct:foo');
+  });
+
+  it('createConsumer returns DirectConsumer', () => {
+    const ctx = new CamelContext();
+    const ep = new DirectEndpoint('direct:foo', ctx);
+    const pipeline = mutatingPipeline('hit', true);
+    const consumer = ep.createConsumer(pipeline);
+    assert.ok(consumer instanceof DirectConsumer);
+    assert.equal(consumer.uri, 'direct:foo');
+  });
+});
+
+describe('DirectConsumer', () => {
+  it('start() registers with context; getConsumer returns it', async () => {
+    const ctx = new CamelContext();
+    const pipeline = mutatingPipeline('hit', true);
+    const consumer = new DirectConsumer('direct:bar', ctx, pipeline);
+
+    await consumer.start();
+    assert.strictEqual(ctx.getConsumer('direct:bar'), consumer);
+  });
+
+  it('stop() deregisters from context', async () => {
+    const ctx = new CamelContext();
+    const pipeline = mutatingPipeline('hit', true);
+    const consumer = new DirectConsumer('direct:bar', ctx, pipeline);
+
+    await consumer.start();
+    await consumer.stop();
+    assert.equal(ctx.getConsumer('direct:bar'), null);
+  });
+
+  it('process() runs the pipeline on the exchange', async () => {
+    const ctx = new CamelContext();
+    const pipeline = mutatingPipeline('processed', 42);
+    const consumer = new DirectConsumer('direct:baz', ctx, pipeline);
+
+    const exchange = new Exchange();
+    await consumer.process(exchange);
+    assert.equal(exchange.getProperty('processed'), 42);
+  });
+});
+
+describe('DirectProducer', () => {
+  it('send() dispatches through consumer and exchange is mutated', async () => {
+    const ctx = new CamelContext();
+    const pipeline = mutatingPipeline('answer', 99);
+    const consumer = new DirectConsumer('direct:qux', ctx, pipeline);
+    await consumer.start();
+
+    const producer = new DirectProducer('direct:qux', ctx);
+    const exchange = new Exchange();
+    await producer.send(exchange);
+
+    assert.equal(exchange.getProperty('answer'), 99);
+  });
+
+  it('send() throws an error when no consumer is registered', async () => {
+    const ctx = new CamelContext();
+    const producer = new DirectProducer('direct:missing', ctx);
+    const exchange = new Exchange();
+
+    await assert.rejects(
+      () => producer.send(exchange),
+      { message: 'No consumer registered for: direct:missing' }
+    );
+  });
+
+  it('send() throws CycleDetectedError when cycle detected', async () => {
+    const ctx = new CamelContext();
+
+    // A consumer whose pipeline calls back into the same URI — simulates a cycle
+    const cyclingPipeline = new Pipeline([
+      async (exchange) => {
+        // Directly invoke the producer again to create the cycle
+        const innerProducer = new DirectProducer('direct:cycle', ctx);
+        await innerProducer.send(exchange);
+      },
+    ]);
+
+    const consumer = new DirectConsumer('direct:cycle', ctx, cyclingPipeline);
+    await consumer.start();
+
+    const producer = new DirectProducer('direct:cycle', ctx);
+    const exchange = new Exchange();
+
+    // Pipeline catches errors into exchange.exception
+    await producer.send(exchange);
+    assert.ok(exchange.isFailed(), 'exchange should be failed');
+    assert.ok(exchange.exception instanceof CycleDetectedError,
+      `expected CycleDetectedError, got ${exchange.exception?.constructor?.name}`);
+  });
+
+  it('direct call stack is restored after send() completes', async () => {
+    const ctx = new CamelContext();
+    const pipeline = mutatingPipeline('done', true);
+    const consumer = new DirectConsumer('direct:restore', ctx, pipeline);
+    await consumer.start();
+
+    const producer = new DirectProducer('direct:restore', ctx);
+    const exchange = new Exchange();
+    await producer.send(exchange);
+
+    // After send completes, stack should be back to empty/original
+    const stack = exchange.getProperty('camel.directStack');
+    assert.deepEqual(stack, []);
+  });
+});

package/test/import.test.js

@@ -0,0 +1,30 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { Exchange, Message, CamelContext, Component, Pipeline, CycleDetectedError } from '@alt-javascript/camel-lite-core';
+import { DirectComponent, DirectEndpoint, DirectProducer, DirectConsumer } from '@alt-javascript/camel-lite-component-direct';
+
+describe('cross-package import integration', () => {
+  it('Exchange imported from camel-lite-core constructs correctly', () => {
+    const ex = new Exchange();
+    assert.equal(ex.pattern, 'InOnly');
+    assert.ok(ex.in instanceof Message);
+  });
+
+  it('Message has a messageId', () => {
+    const msg = new Message();
+    assert.ok(typeof msg.messageId === 'string');
+    assert.ok(msg.messageId.length > 0);
+  });
+
+  it('DirectComponent is a subclass of Component', () => {
+    const dc = new DirectComponent();
+    assert.ok(dc instanceof Component);
+  });
+
+  it('DirectComponent.createEndpoint returns a DirectEndpoint', () => {
+    const dc = new DirectComponent();
+    const ctx = new CamelContext();
+    const ep = dc.createEndpoint('direct:foo', 'foo', {}, ctx);
+    assert.ok(ep instanceof DirectEndpoint);
+  });
+});