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

package/README.md

@@ -0,0 +1,54 @@
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## What
+
+HTTP producer for outbound fetch requests. Sends the exchange body as the request body and sets the response body on the exchange. Producer-only — there is no embedded server/consumer. For inbound HTTP, use [Hono](https://hono.dev/) or Express and bridge via `direct:`.
+
+## Install
+
+```sh
+npm install camel-lite-component-http
+```
+
+## URI Syntax
+
+```
+http://host/path[?method=GET&contentType=application/json&headers.X-Custom=value]
+```
+
+| Parameter      | Default              | Description |
+|----------------|----------------------|-------------|
+| `method`       | `GET`                | HTTP method: `GET`, `POST`, `PUT`, `DELETE`, or `PATCH`. |
+| `contentType`  | `application/json`   | Value for the `Content-Type` request header. |
+| `headers.*`    | *(none)*             | Additional request headers. e.g. `headers.Authorization=Bearer+token`. |
+
+## Usage
+
+```js
+import { CamelContext } from 'camel-lite-core';
+import { HttpComponent } from 'camel-lite-component-http';
+
+const context = new CamelContext();
+context.addComponent('http', new HttpComponent());
+
+context.addRoutes({
+  configure(ctx) {
+    ctx.from('direct:callApi')
+      .to('http://api.example.com/users?method=POST&contentType=application/json');
+  }
+});
+
+await context.start();
+
+const template = context.createProducerTemplate();
+const exchange = await template.send('direct:callApi', ex => {
+  ex.in.body = JSON.stringify({ name: 'Alice' });
+});
+console.log('Response:', exchange.in.body);
+
+await context.stop();
+```
+
+## See Also
+
+[camel-lite — root README](../../README.md)

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@alt-javascript/camel-lite-component-http",
+  "version": "1.0.2",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "dependencies": {
+    "@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",
+    "http",
+    "https",
+    "rest",
+    "component"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/src/HttpComponent.js

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

package/src/HttpEndpoint.js

@@ -0,0 +1,55 @@
+import { Endpoint } from '@alt-javascript/camel-lite-core';
+import HttpProducer from './HttpProducer.js';
+
+class HttpEndpoint extends Endpoint {
+  #uri;
+  #url;
+  #method;
+
+  constructor(uri, remaining, parameters, context) {
+    super();
+    this.#uri = uri;
+
+    const params = parameters instanceof URLSearchParams
+      ? parameters
+      : new URLSearchParams(typeof parameters === 'string' ? parameters : '');
+
+    this.#method = (params.get('method') ?? 'GET').toUpperCase();
+
+    // Reconstruct the full URL from the original URI:
+    // 'http:example.com/path?method=GET' → 'http://example.com/path'
+    // Strip the camel-lite scheme prefix and any component-level query params.
+    // The URI already contains the real scheme (http/https) so we just fix the
+    // double-colon: 'http:host/path' → 'http://host/path'
+    const colonIdx = uri.indexOf(':');
+    const scheme = colonIdx >= 0 ? uri.slice(0, colonIdx) : 'http';
+    const afterScheme = colonIdx >= 0 ? uri.slice(colonIdx + 1) : uri;
+
+    // Strip leading slashes that aren't part of the authority (Camel URIs use single colon)
+    // then reconstruct proper URL
+    const withoutLeadingSlashes = afterScheme.replace(/^\/\//, '');
+
+    // Strip component-level query params (method=, etc.) — keep only real URL query params
+    // by rebuilding: take the raw remaining which has path+query, but strip known params
+    const realParams = new URLSearchParams(params);
+    realParams.delete('method');
+    const queryStr = realParams.toString();
+    const pathWithoutQuery = remaining.split('?')[0];
+    this.#url = `${scheme}://${pathWithoutQuery}${queryStr ? '?' + queryStr : ''}`;
+  }
+
+  get uri() { return this.#uri; }
+  get url() { return this.#url; }
+  get method() { return this.#method; }
+
+  createProducer() {
+    return new HttpProducer(this.#url, this.#method);
+  }
+
+  createConsumer() {
+    throw new Error('http: component is producer-only (see D005)');
+  }
+}
+
+export { HttpEndpoint };
+export default HttpEndpoint;

package/src/HttpProducer.js

@@ -0,0 +1,56 @@
+import { Producer } from '@alt-javascript/camel-lite-core';
+import { LoggerFactory } from '@alt-javascript/logger';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/HttpProducer');
+
+const BODY_METHODS = new Set(['POST', 'PUT', 'PATCH']);
+
+class HttpProducer extends Producer {
+  #url;
+  #method;
+
+  constructor(url, method = 'GET') {
+    super();
+    this.#url = url;
+    this.#method = method.toUpperCase();
+  }
+
+  get url() { return this.#url; }
+  get method() { return this.#method; }
+
+  async send(exchange) {
+    // Method: CamelHttpMethod header > constructor default
+    const method = (exchange.in.getHeader('CamelHttpMethod') ?? this.#method).toUpperCase();
+
+    // Optional override URL from header
+    const url = exchange.in.getHeader('CamelHttpUri') ?? this.#url;
+
+    // Build request body for POST/PUT/PATCH
+    let body = undefined;
+    if (BODY_METHODS.has(method) && exchange.in.body != null) {
+      body = typeof exchange.in.body === 'string'
+        ? exchange.in.body
+        : JSON.stringify(exchange.in.body);
+    }
+
+    log.debug(`HTTP ${method} ${url}`);
+
+    const response = await fetch(url, { method, body });
+
+    log.info(`HTTP ${response.status} ${url}`);
+
+    const responseBody = await response.text();
+
+    exchange.out.body = responseBody;
+    exchange.out.setHeader('CamelHttpResponseCode', response.status);
+    exchange.out.setHeader('CamelHttpResponseText', response.statusText);
+
+    // Copy all response headers
+    for (const [key, value] of response.headers) {
+      exchange.out.setHeader(key, value);
+    }
+  }
+}
+
+export { HttpProducer };
+export default HttpProducer;

package/src/index.js

@@ -0,0 +1,6 @@
+export { HttpComponent } from './HttpComponent.js';
+export { HttpEndpoint } from './HttpEndpoint.js';
+export { HttpProducer } from './HttpProducer.js';
+
+import HttpComponent from './HttpComponent.js';
+export default HttpComponent;

package/test/http.test.js

@@ -0,0 +1,172 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { CamelContext, Exchange, Component } from '@alt-javascript/camel-lite-core';
+import { HttpComponent, HttpEndpoint, HttpProducer } from '@alt-javascript/camel-lite-component-http';
+
+// Spin a minimal local HTTP server for testing — no external network calls
+function makeTestServer(handler) {
+  return new Promise((resolve) => {
+    const server = createServer(handler);
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      resolve({ server, port });
+    });
+  });
+}
+
+describe('HttpProducer', () => {
+  it('GET request: exchange.out.body contains response and CamelHttpResponseCode is 200', async () => {
+    const { server, port } = await makeTestServer((req, res) => {
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, method: req.method }));
+    });
+
+    try {
+      const producer = new HttpProducer(`http://127.0.0.1:${port}/test`);
+      const exchange = new Exchange();
+      await producer.send(exchange);
+
+      assert.equal(exchange.out.getHeader('CamelHttpResponseCode'), 200);
+      const body = JSON.parse(exchange.out.body);
+      assert.equal(body.ok, true);
+      assert.equal(body.method, 'GET');
+      assert.equal(exchange.exception, null);
+    } finally {
+      await new Promise(r => server.close(r));
+    }
+  });
+
+  it('POST request sends body and receives echo', async () => {
+    const { server, port } = await makeTestServer((req, res) => {
+      let data = '';
+      req.on('data', c => { data += c; });
+      req.on('end', () => {
+        res.writeHead(200, { 'content-type': 'text/plain' });
+        res.end('echo:' + data);
+      });
+    });
+
+    try {
+      const producer = new HttpProducer(`http://127.0.0.1:${port}/echo`, 'POST');
+      const exchange = new Exchange();
+      exchange.in.body = 'ping';
+      await producer.send(exchange);
+
+      assert.equal(exchange.out.getHeader('CamelHttpResponseCode'), 200);
+      assert.equal(exchange.out.body, 'echo:ping');
+    } finally {
+      await new Promise(r => server.close(r));
+    }
+  });
+
+  it('CamelHttpMethod header overrides default method', async () => {
+    const methods = [];
+    const { server, port } = await makeTestServer((req, res) => {
+      methods.push(req.method);
+      res.writeHead(200);
+      res.end('ok');
+    });
+
+    try {
+      // Default is GET, but header overrides to PUT
+      const producer = new HttpProducer(`http://127.0.0.1:${port}/`);
+      const exchange = new Exchange();
+      exchange.in.setHeader('CamelHttpMethod', 'PUT');
+      exchange.in.body = 'data';
+      await producer.send(exchange);
+
+      assert.equal(methods[0], 'PUT');
+    } finally {
+      await new Promise(r => server.close(r));
+    }
+  });
+
+  it('404 response: CamelHttpResponseCode is 404, exchange.exception is null', async () => {
+    const { server, port } = await makeTestServer((req, res) => {
+      res.writeHead(404);
+      res.end('not found');
+    });
+
+    try {
+      const producer = new HttpProducer(`http://127.0.0.1:${port}/missing`);
+      const exchange = new Exchange();
+      await producer.send(exchange);
+
+      // HTTP errors are not exceptions — they land in exchange.out
+      assert.equal(exchange.out.getHeader('CamelHttpResponseCode'), 404);
+      assert.equal(exchange.out.body, 'not found');
+      assert.equal(exchange.exception, null);
+    } finally {
+      await new Promise(r => server.close(r));
+    }
+  });
+
+  it('POST with object body: serialised as JSON', async () => {
+    let receivedBody = '';
+    const { server, port } = await makeTestServer((req, res) => {
+      let data = '';
+      req.on('data', c => { data += c; });
+      req.on('end', () => {
+        receivedBody = data;
+        res.writeHead(200);
+        res.end('ok');
+      });
+    });
+
+    try {
+      const producer = new HttpProducer(`http://127.0.0.1:${port}/`, 'POST');
+      const exchange = new Exchange();
+      exchange.in.body = { hello: 'world' };
+      await producer.send(exchange);
+
+      assert.deepEqual(JSON.parse(receivedBody), { hello: 'world' });
+    } finally {
+      await new Promise(r => server.close(r));
+    }
+  });
+});
+
+describe('HttpEndpoint', () => {
+  it('reconstructs URL correctly from URI', () => {
+    const ctx = new CamelContext();
+    const ep = new HttpEndpoint(
+      'http:example.com/api/v1',
+      'example.com/api/v1',
+      new URLSearchParams(),
+      ctx
+    );
+    assert.equal(ep.url, 'http://example.com/api/v1');
+    assert.equal(ep.method, 'GET');
+  });
+
+  it('method= URI param sets default method', () => {
+    const ctx = new CamelContext();
+    const ep = new HttpEndpoint(
+      'http:example.com/api?method=POST',
+      'example.com/api',
+      new URLSearchParams('method=POST'),
+      ctx
+    );
+    assert.equal(ep.method, 'POST');
+  });
+
+  it('createConsumer throws (producer-only)', () => {
+    const ctx = new CamelContext();
+    const ep = new HttpEndpoint('http:example.com', 'example.com', new URLSearchParams(), ctx);
+    assert.throws(() => ep.createConsumer(), { message: /producer-only/ });
+  });
+});
+
+describe('cross-package import integration', () => {
+  it('HttpComponent is a subclass of Component', () => {
+    assert.ok(new HttpComponent() instanceof Component);
+  });
+
+  it('HttpComponent.createEndpoint returns HttpEndpoint', () => {
+    const ctx = new CamelContext();
+    const comp = new HttpComponent();
+    const ep = comp.createEndpoint('http:example.com', 'example.com', new URLSearchParams(), ctx);
+    assert.ok(ep instanceof HttpEndpoint);
+  });
+});