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

package/README.md

@@ -0,0 +1,63 @@
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## What
+
+NoSQL collection operations via [`@alt-javascript/jsnosqlc`](https://www.npmjs.com/package/@alt-javascript/jsnosqlc). Supports insert, find, update, delete, and count against named collections.
+
+## Install
+
+```sh
+npm install camel-lite-component-nosql @alt-javascript/jsnosqlc
+```
+
+## URI Syntax
+
+```
+nosql:collectionName[?url=jsnosqlc:memory:&operation=insert]
+```
+
+| Parameter    | Default          | Description |
+|--------------|------------------|-------------|
+| `url`        | *(required)*     | jsnosqlc connection URL (e.g. `jsnosqlc:memory:` or a file path). |
+| `operation`  | `insert`         | Collection operation: `insert`, `find`, `update`, `delete`, or `count`. |
+
+## Usage
+
+```js
+import { CamelContext } from 'camel-lite-core';
+import { NosqlComponent } from 'camel-lite-component-nosql';
+
+const context = new CamelContext();
+context.addComponent('nosql', new NosqlComponent());
+
+context.addRoutes({
+  configure(ctx) {
+    // Insert exchange body as a document
+    ctx.from('direct:storeEvent')
+      .to('nosql:events?url=jsnosqlc:memory:&operation=insert');
+
+    // Find documents — exchange body used as the query filter
+    ctx.from('direct:queryEvents')
+      .to('nosql:events?url=jsnosqlc:memory:&operation=find');
+  }
+});
+
+await context.start();
+
+const template = context.createProducerTemplate();
+
+// Insert
+await template.sendBody('direct:storeEvent', { type: 'login', userId: 7 });
+
+// Find — pass a filter object as body
+const exchange = await template.send('direct:queryEvents', ex => {
+  ex.in.body = { type: 'login' };
+});
+console.log('Found:', exchange.in.body);
+
+await context.stop();
+```
+
+## See Also
+
+[camel-lite — root README](../../README.md)

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@alt-javascript/camel-lite-component-nosql",
+  "version": "1.0.2",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "dependencies": {
+    "@alt-javascript/jsnosqlc-core": "^1.1.1",
+    "@alt-javascript/jsnosqlc-memory": "^1.1.1",
+    "@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",
+    "nosql",
+    "mongodb",
+    "component"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/src/NosqlComponent.js

@@ -0,0 +1,142 @@
+import { Component } from '@alt-javascript/camel-lite-core';
+import { LoggerFactory } from '@alt-javascript/logger';
+import { NosqlEndpoint } from './NosqlEndpoint.js';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/NosqlComponent');
+
+/**
+ * NosqlComponent — executes NoSQL operations as a pipeline step via
+ * the @alt-javascript/jsnosqlc abstraction layer.
+ *
+ * Datasource resolution (three-step chain, evaluated at send() time):
+ *
+ *   1. Component-internal map  — setDatasource(name, factory) takes priority.
+ *
+ *   2. Context bean by name    — context.getBean(name) is checked when the
+ *      component map has no match. The bean may be a ClientDataSource
+ *      (has .getClient()) or a jsnosqlc Client directly.
+ *
+ *   3. Auto-select             — when no explicit name is given (or named lookup
+ *      found nothing) and context.getBeans() has exactly one entry, that bean
+ *      is used automatically.
+ *
+ * URI formats:
+ *   nosql:collection?datasource=myDsBean&operation=insert
+ *   nosql:collection?operation=insert        ← auto-select when 1 bean in ctx
+ *
+ * Operations (jsnosqlc Collection API):
+ *   get    — exchange.in.body = key (string)         → exchange.in.body = doc | null
+ *   store  — exchange.in.body = { key, doc }         → exchange.in.body = undefined
+ *   delete — exchange.in.body = key (string)         → exchange.in.body = undefined
+ *   insert — exchange.in.body = doc (object)         → exchange.in.body = assigned key
+ *   update — exchange.in.body = { key, patch }       → exchange.in.body = undefined
+ *   find   — exchange.in.body = Filter (built AST)   → exchange.in.body = doc array
+ */
+class NosqlComponent extends Component {
+  #datasources = new Map();   // name → factory function
+  #clients = new Map();       // name → cached Client (from component-map factories)
+  #endpoints = new Map();
+
+  /**
+   * Register a named datasource factory on the component.
+   * Factory is () => ClientDataSource | Client (sync or async result).
+   * @param {string} name
+   * @param {function} factory
+   */
+  setDatasource(name, factory) {
+    this.#datasources.set(name, factory);
+    log.info(`NosqlComponent: datasource '${name}' registered on component`);
+    return this;
+  }
+
+  /**
+   * Resolve and return a jsnosqlc Client using the three-step chain.
+   * Clients from the component-internal map are cached.
+   * @param {string|null} name
+   * @param {CamelContext|null} context
+   * @returns {Promise<import('@alt-javascript/jsnosqlc-core').Client>}
+   */
+  async getClient(name, context = null) {
+    // Step 1: component-internal map
+    if (name && this.#datasources.has(name)) {
+      if (this.#clients.has(name)) {
+        return this.#clients.get(name);
+      }
+      log.debug(`NosqlComponent: datasource '${name}' resolved from component map`);
+      const factoryResult = this.#datasources.get(name)();
+      const client = typeof factoryResult.getClient === 'function'
+        ? await factoryResult.getClient()
+        : await factoryResult;
+      this.#clients.set(name, client);
+      log.info(`NosqlComponent: client acquired for datasource '${name}'`);
+      return client;
+    }
+
+    if (context) {
+      // Step 2: context bean by name
+      if (name) {
+        const bean = context.getBean(name);
+        if (bean != null) {
+          const cacheKey = `__ctx__:${name}`;
+          if (this.#clients.has(cacheKey)) {
+            return this.#clients.get(cacheKey);
+          }
+          log.debug(`NosqlComponent: datasource '${name}' resolved from context bean`);
+          const client = typeof bean.getClient === 'function' ? await bean.getClient() : bean;
+          this.#clients.set(cacheKey, client);
+          return client;
+        }
+      }
+
+      // Step 3: single-bean auto-select
+      const allBeans = context.getBeans();
+      if (allBeans.length === 1) {
+        const [beanName, bean] = allBeans[0];
+        const cacheKey = `__ctx__:${beanName}`;
+        if (this.#clients.has(cacheKey)) {
+          return this.#clients.get(cacheKey);
+        }
+        log.debug(`NosqlComponent: datasource auto-selected (single bean in context: '${beanName}')`);
+        const client = typeof bean.getClient === 'function' ? await bean.getClient() : bean;
+        this.#clients.set(cacheKey, client);
+        return client;
+      }
+    }
+
+    throw new Error(
+      `NosqlComponent: cannot resolve datasource '${name ?? '(none)'}'. ` +
+      `Register via component.setDatasource(), context.registerBean(), ` +
+      `or ensure exactly one bean is registered in context.`
+    );
+  }
+
+  /**
+   * Close all cached clients from the component-internal map.
+   */
+  async close() {
+    for (const [name, client] of this.#clients) {
+      await client.close().catch(() => {});
+      log.info(`NosqlComponent: client closed for datasource '${name}'`);
+    }
+    this.#clients.clear();
+  }
+
+  createEndpoint(uri, remaining, parameters, context) {
+    if (this.#endpoints.has(uri)) {
+      return this.#endpoints.get(uri);
+    }
+
+    const collection = remaining.replace(/^\/+/, '') || 'default';
+    const datasource = parameters.get('datasource') ?? null;  // null = auto-select
+    const operation = parameters.get('operation') ?? 'get';
+
+    log.info(`NosqlComponent creating endpoint: collection=${collection}, datasource=${datasource ?? '(auto)'}, op=${operation}`);
+
+    const endpoint = new NosqlEndpoint(uri, collection, datasource, operation, context, this);
+    this.#endpoints.set(uri, endpoint);
+    return endpoint;
+  }
+}
+
+export { NosqlComponent };
+export default NosqlComponent;

package/src/NosqlConsumer.js

@@ -0,0 +1,39 @@
+import { Consumer } from '@alt-javascript/camel-lite-core';
+import { LoggerFactory } from '@alt-javascript/logger';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/NosqlConsumer');
+
+/**
+ * NosqlConsumer — stub implementation.
+ * nosql: is primarily producer-oriented.
+ * Change-stream / poll consumer is deferred to a future milestone.
+ */
+class NosqlConsumer extends Consumer {
+  #endpoint;
+  #pipeline;
+
+  constructor(endpoint, pipeline) {
+    super();
+    this.#endpoint = endpoint;
+    this.#pipeline = pipeline;
+  }
+
+  async start() {
+    const { uri, context } = this.#endpoint;
+    context.registerConsumer(uri, this);
+    log.info(`NosqlConsumer started: ${uri}`);
+  }
+
+  async stop() {
+    const { uri, context } = this.#endpoint;
+    context.registerConsumer(uri, null);
+    log.info(`NosqlConsumer stopped: ${uri}`);
+  }
+
+  async process(exchange) {
+    return this.#pipeline.run(exchange);
+  }
+}
+
+export { NosqlConsumer };
+export default NosqlConsumer;

package/src/NosqlEndpoint.js

@@ -0,0 +1,43 @@
+import { Endpoint } from '@alt-javascript/camel-lite-core';
+import { NosqlProducer } from './NosqlProducer.js';
+import { NosqlConsumer } from './NosqlConsumer.js';
+
+/**
+ * NosqlEndpoint holds the parsed URI state for a nosql: endpoint.
+ */
+class NosqlEndpoint extends Endpoint {
+  #uri;
+  #collection;
+  #datasource;
+  #operation;
+  #context;
+  #component;
+
+  constructor(uri, collection, datasource, operation, context, component) {
+    super();
+    this.#uri = uri;
+    this.#collection = collection;
+    this.#datasource = datasource;
+    this.#operation = operation;
+    this.#context = context;
+    this.#component = component;
+  }
+
+  get uri() { return this.#uri; }
+  get collection() { return this.#collection; }
+  get datasource() { return this.#datasource; }
+  get operation() { return this.#operation; }
+  get context() { return this.#context; }
+  get component() { return this.#component; }
+
+  createProducer() {
+    return new NosqlProducer(this);
+  }
+
+  createConsumer(pipeline) {
+    return new NosqlConsumer(this, pipeline);
+  }
+}
+
+export { NosqlEndpoint };
+export default NosqlEndpoint;

package/src/NosqlProducer.js

@@ -0,0 +1,88 @@
+import { Producer } from '@alt-javascript/camel-lite-core';
+import { LoggerFactory } from '@alt-javascript/logger';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/NosqlProducer');
+
+/**
+ * NosqlProducer — executes a jsnosqlc Collection operation as a pipeline step.
+ *
+ * Operation dispatch (endpoint.operation):
+ *
+ *   get    — exchange.in.body = key (string)
+ *            → exchange.in.body = document | null
+ *
+ *   store  — exchange.in.body = { key: string, doc: object }
+ *            → exchange.in.body = undefined  (fire-and-forget upsert)
+ *
+ *   delete — exchange.in.body = key (string)
+ *            → exchange.in.body = undefined
+ *
+ *   insert — exchange.in.body = document (object)
+ *            → exchange.in.body = assigned key (string)
+ *
+ *   update — exchange.in.body = { key: string, patch: object }
+ *            → exchange.in.body = undefined  (patch merge)
+ *
+ *   find   — exchange.in.body = Filter (built AST from Filter.where()...build())
+ *            → exchange.in.body = document[]  (from cursor.getDocuments())
+ */
+class NosqlProducer extends Producer {
+  #endpoint;
+
+  constructor(endpoint) {
+    super();
+    this.#endpoint = endpoint;
+  }
+
+  async send(exchange) {
+    const { collection: collectionName, datasource, operation, component, context } = this.#endpoint;
+
+    log.debug(`NosqlProducer: ${operation} on ${datasource ?? '(auto)'}/${collectionName}`);
+
+    const client = await component.getClient(datasource, context);
+    const col = client.getCollection(collectionName);
+    const body = exchange.in.body;
+
+    switch (operation) {
+      case 'get': {
+        exchange.in.body = await col.get(body);
+        break;
+      }
+      case 'store': {
+        const { key, doc } = body ?? {};
+        await col.store(key, doc);
+        exchange.in.body = undefined;
+        break;
+      }
+      case 'delete': {
+        await col.delete(body);
+        exchange.in.body = undefined;
+        break;
+      }
+      case 'insert': {
+        exchange.in.body = await col.insert(body);
+        break;
+      }
+      case 'update': {
+        const { key, patch } = body ?? {};
+        await col.update(key, patch);
+        exchange.in.body = undefined;
+        break;
+      }
+      case 'find': {
+        // body should be a built Filter AST from Filter.where()...build()
+        // null/undefined body means find all — pass null to driver
+        const cursor = await col.find(body ?? null);
+        exchange.in.body = cursor.getDocuments();
+        break;
+      }
+      default:
+        throw new Error(`NosqlProducer: unknown operation '${operation}'`);
+    }
+
+    log.debug(`NosqlProducer: ${operation} complete on ${datasource}/${collectionName}`);
+  }
+}
+
+export { NosqlProducer };
+export default NosqlProducer;

package/src/index.js

@@ -0,0 +1,8 @@
+export { NosqlComponent } from './NosqlComponent.js';
+export { NosqlEndpoint } from './NosqlEndpoint.js';
+export { NosqlProducer } from './NosqlProducer.js';
+export { NosqlConsumer } from './NosqlConsumer.js';
+
+// Re-export Filter and ClientDataSource from jsnosqlc-core for caller convenience.
+// Callers need Filter to build expressions for find operations.
+export { Filter, ClientDataSource } from '@alt-javascript/jsnosqlc-core';

package/test/nosql.test.js

@@ -0,0 +1,446 @@
+import { describe, it, before } from 'node:test';
+import assert from 'node:assert/strict';
+import { Exchange, CamelContext } from '@alt-javascript/camel-lite-core';
+import { ClientDataSource } from '@alt-javascript/jsnosqlc-core';
+// Self-registers the in-memory driver with DriverManager on import
+import '@alt-javascript/jsnosqlc-memory';
+import { NosqlComponent, Filter } from '@alt-javascript/camel-lite-component-nosql';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeExchange(body) {
+  const ex = new Exchange();
+  ex.in.body = body;
+  return ex;
+}
+
+/** Build a NosqlComponent backed by a fresh in-memory store. */
+function makeComponent(dsName = 'store') {
+  const comp = new NosqlComponent();
+  comp.setDatasource(dsName, () => new ClientDataSource({ url: 'jsnosqlc:memory:' }));
+  return comp;
+}
+
+function makeEndpoint(comp, ctx, collection, operation, dsName = 'store') {
+  const paramStr = `datasource=${dsName}&operation=${operation}`;
+  const uri = `nosql:${collection}?${paramStr}`;
+  const params = new URLSearchParams(paramStr);
+  return comp.createEndpoint(uri, collection, params, ctx);
+}
+
+// ---------------------------------------------------------------------------
+// URI parsing
+// ---------------------------------------------------------------------------
+
+describe('NosqlComponent: URI parsing', () => {
+  it('parses collection, datasource, and operation from URI', () => {
+    const comp = makeComponent();
+    const ctx = new CamelContext();
+    const ep = makeEndpoint(comp, ctx, 'users', 'insert');
+    assert.equal(ep.collection, 'users');
+    assert.equal(ep.datasource, 'store');
+    assert.equal(ep.operation, 'insert');
+  });
+
+  it('defaults operation to get when not specified', () => {
+    const comp = makeComponent();
+    const ctx = new CamelContext();
+    const uri = 'nosql:items?datasource=store';
+    const ep = comp.createEndpoint(uri, 'items', new URLSearchParams('datasource=store'), ctx);
+    assert.equal(ep.operation, 'get');
+  });
+
+  it('returns cached endpoint on duplicate URI', () => {
+    const comp = makeComponent();
+    const ctx = new CamelContext();
+    const ep1 = makeEndpoint(comp, ctx, 'col', 'insert');
+    const ep2 = makeEndpoint(comp, ctx, 'col', 'insert');
+    assert.equal(ep1, ep2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// insert → get round-trip
+// ---------------------------------------------------------------------------
+
+describe('NosqlProducer: insert and get', () => {
+  it('insert returns assigned key; get retrieves the document', async () => {
+    const comp = makeComponent();
+    const ctx = new CamelContext();
+
+    // insert
+    const insertEp = makeEndpoint(comp, ctx, 'products', 'insert');
+    const insertEx = makeExchange({ name: 'Widget', price: 9.99 });
+    await insertEp.createProducer().send(insertEx);
+    const key = insertEx.in.body;
+    assert.equal(typeof key, 'string', 'insert should return a string key');
+
+    // get
+    const getEp = makeEndpoint(comp, ctx, 'products', 'get');
+    const getEx = makeExchange(key);
+    await getEp.createProducer().send(getEx);
+    assert.equal(getEx.in.body.name, 'Widget');
+    assert.equal(getEx.in.body.price, 9.99);
+  });
+
+  it('get returns null for a missing key', async () => {
+    const comp = makeComponent();
+    const ctx = new CamelContext();
+    const ep = makeEndpoint(comp, ctx, 'empty', 'get');
+    const ex = makeExchange('nonexistent-key');
+    await ep.createProducer().send(ex);
+    assert.equal(ex.in.body, null);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// store and get
+// ---------------------------------------------------------------------------
+
+describe('NosqlProducer: store and get', () => {
+  it('store upserts under caller-supplied key; get retrieves it', async () => {
+    const comp = makeComponent();
+    const ctx = new CamelContext();
+
+    const storeEp = makeEndpoint(comp, ctx, 'sessions', 'store');
+    const storeEx = makeExchange({ key: 'sess-abc', doc: { userId: 42, role: 'admin' } });
+    await storeEp.createProducer().send(storeEx);
+    assert.equal(storeEx.in.body, undefined);
+
+    const getEp = makeEndpoint(comp, ctx, 'sessions', 'get');
+    const getEx = makeExchange('sess-abc');
+    await getEp.createProducer().send(getEx);
+    assert.equal(getEx.in.body.userId, 42);
+    assert.equal(getEx.in.body.role, 'admin');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// delete
+// ---------------------------------------------------------------------------
+
+describe('NosqlProducer: delete', () => {
+  it('delete removes document; subsequent get returns null', async () => {
+    const comp = makeComponent();
+    const ctx = new CamelContext();
+
+    // store first
+    await makeEndpoint(comp, ctx, 'cache', 'store').createProducer()
+      .send(makeExchange({ key: 'temp', doc: { x: 1 } }));
+
+    // delete
+    const delEp = makeEndpoint(comp, ctx, 'cache', 'delete');
+    const delEx = makeExchange('temp');
+    await delEp.createProducer().send(delEx);
+    assert.equal(delEx.in.body, undefined);
+
+    // get → null
+    const getEx = makeExchange('temp');
+    await makeEndpoint(comp, ctx, 'cache', 'get').createProducer().send(getEx);
+    assert.equal(getEx.in.body, null);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// update
+// ---------------------------------------------------------------------------
+
+describe('NosqlProducer: update', () => {
+  it('update patches document fields; others preserved', async () => {
+    const comp = makeComponent();
+    const ctx = new CamelContext();
+
+    // insert a document
+    const insertEx = makeExchange({ name: 'Alice', age: 30, role: 'user' });
+    await makeEndpoint(comp, ctx, 'users', 'insert').createProducer().send(insertEx);
+    const key = insertEx.in.body;
+
+    // update — patch age and role, name should be preserved
+    const updateEx = makeExchange({ key, patch: { age: 31, role: 'admin' } });
+    await makeEndpoint(comp, ctx, 'users', 'update').createProducer().send(updateEx);
+    assert.equal(updateEx.in.body, undefined);
+
+    // verify patch applied and name preserved
+    const getEx = makeExchange(key);
+    await makeEndpoint(comp, ctx, 'users', 'get').createProducer().send(getEx);
+    assert.equal(getEx.in.body.name, 'Alice');
+    assert.equal(getEx.in.body.age, 31);
+    assert.equal(getEx.in.body.role, 'admin');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// find
+// ---------------------------------------------------------------------------
+
+describe('NosqlProducer: find', () => {
+  it('find with Filter returns matching documents as array', async () => {
+    const comp = makeComponent();
+    const ctx = new CamelContext();
+
+    // insert 3 documents
+    const insertEp = makeEndpoint(comp, ctx, 'items', 'insert');
+    await insertEp.createProducer().send(makeExchange({ name: 'Widget', price: 9.99 }));
+    await insertEp.createProducer().send(makeExchange({ name: 'Gadget', price: 24.99 }));
+    await insertEp.createProducer().send(makeExchange({ name: 'Donut', price: 1.99 }));
+
+    // find where price < 10
+    const filter = Filter.where('price').lt(10).build();
+    const findEp = makeEndpoint(comp, ctx, 'items', 'find');
+    const findEx = makeExchange(filter);
+    await findEp.createProducer().send(findEx);
+
+    assert.ok(Array.isArray(findEx.in.body), 'result should be an array');
+    assert.equal(findEx.in.body.length, 2);
+    const names = findEx.in.body.map(d => d.name).sort();
+    assert.deepEqual(names, ['Donut', 'Widget']);
+  });
+
+  it('find with eq filter returns exact matches', async () => {
+    const comp = makeComponent();
+    const ctx = new CamelContext();
+
+    const insertEp = makeEndpoint(comp, ctx, 'users', 'insert');
+    await insertEp.createProducer().send(makeExchange({ name: 'Alice', role: 'admin' }));
+    await insertEp.createProducer().send(makeExchange({ name: 'Bob', role: 'user' }));
+    await insertEp.createProducer().send(makeExchange({ name: 'Carol', role: 'admin' }));
+
+    const filter = Filter.where('role').eq('admin').build();
+    const findEx = makeExchange(filter);
+    await makeEndpoint(comp, ctx, 'users', 'find').createProducer().send(findEx);
+
+    assert.equal(findEx.in.body.length, 2);
+    assert.ok(findEx.in.body.every(d => d.role === 'admin'));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Multiple named datasources
+// ---------------------------------------------------------------------------
+
+describe('NosqlComponent: multiple datasources', () => {
+  it('routes operations to the correct named datasource', async () => {
+    const comp = new NosqlComponent();
+    comp.setDatasource('ds1', () => new ClientDataSource({ url: 'jsnosqlc:memory:' }));
+    comp.setDatasource('ds2', () => new ClientDataSource({ url: 'jsnosqlc:memory:' }));
+
+    const ctx = new CamelContext();
+
+    const ep1 = comp.createEndpoint('nosql:col?datasource=ds1&operation=insert', 'col', new URLSearchParams('datasource=ds1&operation=insert'), ctx);
+    const ep2 = comp.createEndpoint('nosql:col?datasource=ds2&operation=insert', 'col', new URLSearchParams('datasource=ds2&operation=insert'), ctx);
+
+    const ex1 = makeExchange({ from: 'ds1' });
+    const ex2 = makeExchange({ from: 'ds2' });
+
+    await ep1.createProducer().send(ex1);
+    await ep2.createProducer().send(ex2);
+
+    // Keys are different strings — just check both were created
+    assert.equal(typeof ex1.in.body, 'string');
+    assert.equal(typeof ex2.in.body, 'string');
+    assert.notEqual(ex1.in.body, ex2.in.body);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Error cases
+// ---------------------------------------------------------------------------
+
+describe('NosqlComponent: error cases', () => {
+  it('throws on unknown operation', async () => {
+    const comp = makeComponent();
+    const ctx = new CamelContext();
+    const ep = comp.createEndpoint('nosql:col?datasource=store&operation=truncate', 'col', new URLSearchParams('datasource=store&operation=truncate'), ctx);
+
+    await assert.rejects(
+      () => ep.createProducer().send(makeExchange(null)),
+      /unknown operation 'truncate'/i
+    );
+  });
+
+  it('throws when datasource is not registered', async () => {
+    const comp = new NosqlComponent(); // no datasources registered
+    const ctx = new CamelContext();
+    const ep = makeEndpoint(comp, ctx, 'col', 'insert', 'ghost');
+
+    await assert.rejects(
+      () => ep.createProducer().send(makeExchange({ x: 1 })),
+      /cannot resolve datasource 'ghost'/i
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// NosqlComponent.close() releases clients
+// ---------------------------------------------------------------------------
+
+describe('NosqlComponent: close', () => {
+  it('close() closes all cached clients', async () => {
+    const comp = makeComponent();
+    const ctx = new CamelContext();
+
+    // Trigger client creation
+    const ep = makeEndpoint(comp, ctx, 'col', 'insert');
+    await ep.createProducer().send(makeExchange({ x: 1 }));
+
+    // close
+    await comp.close();
+
+    // Subsequent calls re-create client from factory (not throw)
+    // — just verify close() does not throw
+    // No assertion beyond no-throw is needed here
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Integration tests (conditional on NOSQL_URL)
+// ---------------------------------------------------------------------------
+
+const NOSQL_URL = process.env.NOSQL_URL;
+
+if (NOSQL_URL) {
+  describe('NoSQL integration (live backend via NOSQL_URL)', () => {
+    it('round-trips insert → get → delete via live driver', async () => {
+      const comp = new NosqlComponent();
+      comp.setDatasource('live', () => new ClientDataSource({ url: NOSQL_URL }));
+      const ctx = new CamelContext();
+
+      const collName = `camel_lite_test`;
+      const insertEp = makeEndpoint(comp, ctx, collName, 'insert', 'live');
+      const getEp = makeEndpoint(comp, ctx, collName, 'get', 'live');
+      const deleteEp = makeEndpoint(comp, ctx, collName, 'delete', 'live');
+
+      const insertEx = makeExchange({ testField: 'integration', ts: Date.now() });
+      await insertEp.createProducer().send(insertEx);
+      const key = insertEx.in.body;
+      assert.ok(key, 'should have a key after insert');
+
+      const getEx = makeExchange(key);
+      await getEp.createProducer().send(getEx);
+      assert.equal(getEx.in.body.testField, 'integration');
+
+      const delEx = makeExchange(key);
+      await deleteEp.createProducer().send(delEx);
+
+      await comp.close();
+    });
+  });
+} else {
+  describe('NoSQL integration (skipped — set NOSQL_URL=jsnosqlc:mongodb://... to enable)', () => {
+    it('skipped', () => { /* no-op */ });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Context-aware datasource resolution (three-step chain)
+// ---------------------------------------------------------------------------
+
+describe('NosqlComponent: context bean resolution', () => {
+  function makeDs() {
+    return new ClientDataSource({ url: 'jsnosqlc:memory:' });
+  }
+
+  async function seedCollection(ds, collName, docs) {
+    const client = await ds.getClient();
+    const col = client.getCollection(collName);
+    for (const doc of docs) await col.insert(doc);
+    // Note: we intentionally don't close the client here — the component will cache it.
+  }
+
+  it('step 2: resolves datasource from context.getBean(name) when not in component map', async () => {
+    const ds = makeDs();
+    const comp = new NosqlComponent(); // no setDatasource()
+    const ctx = new CamelContext();
+    ctx.registerBean('myStore', ds);
+
+    // Seed data through the component so it uses the cached client
+    const insertParams = new URLSearchParams('datasource=myStore&operation=insert');
+    const insertEp = comp.createEndpoint('nosql:things?datasource=myStore&operation=insert', 'things', insertParams, ctx);
+    await insertEp.createProducer().send(makeExchange({ x: 42 }));
+
+    const params = new URLSearchParams('datasource=myStore&operation=find');
+    const ep = comp.createEndpoint('nosql:things?datasource=myStore&operation=find', 'things', params, ctx);
+
+    const ex = makeExchange(null);
+    await ep.createProducer().send(ex);
+
+    assert.ok(Array.isArray(ex.in.body));
+    assert.equal(ex.in.body.length, 1);
+    assert.equal(ex.in.body[0].x, 42);
+  });
+
+  it('step 3: auto-selects single context bean when no datasource given', async () => {
+    const ds = makeDs();
+    const comp = new NosqlComponent();
+    const ctx = new CamelContext();
+    ctx.registerBean('onlyStore', ds); // exactly one bean
+
+    // Seed via component (auto-select)
+    const insertParams = new URLSearchParams('operation=insert');
+    const insertEp = comp.createEndpoint('nosql:items?operation=insert', 'items', insertParams, ctx);
+    await insertEp.createProducer().send(makeExchange({ name: 'auto' }));
+
+    const params = new URLSearchParams('operation=find');
+    const ep = comp.createEndpoint('nosql:items?operation=find', 'items', params, ctx);
+
+    const ex = makeExchange(null);
+    await ep.createProducer().send(ex);
+
+    assert.equal(ex.in.body.length, 1);
+    assert.equal(ex.in.body[0].name, 'auto');
+  });
+
+  it('step 1 takes priority over context bean when component map has same name', async () => {
+    const dsInMap = makeDs();
+    const dsInContext = makeDs();
+
+    const comp = new NosqlComponent();
+    comp.setDatasource('store', () => dsInMap);
+
+    const ctx = new CamelContext();
+    ctx.registerBean('store', dsInContext);
+
+    // Insert via component map path
+    const insertParams = new URLSearchParams('datasource=store&operation=insert');
+    const insertEp = comp.createEndpoint('nosql:col?datasource=store&operation=insert', 'col', insertParams, ctx);
+    await insertEp.createProducer().send(makeExchange({ from: 'map' }));
+
+    const params = new URLSearchParams('datasource=store&operation=find');
+    const ep = comp.createEndpoint('nosql:col?datasource=store&operation=find', 'col', params, ctx);
+    const ex = makeExchange(null);
+    await ep.createProducer().send(ex);
+
+    // Should read from dsInMap (1 doc), not dsInContext (0 docs)
+    assert.equal(ex.in.body.length, 1);
+    assert.equal(ex.in.body[0].from, 'map');
+  });
+
+  it('throws descriptive error when no resolution path succeeds', async () => {
+    const comp = new NosqlComponent();
+    const ctx = new CamelContext(); // no beans
+    const params = new URLSearchParams('datasource=ghost&operation=insert');
+    const ep = comp.createEndpoint('nosql:col?datasource=ghost&operation=insert', 'col', params, ctx);
+
+    await assert.rejects(
+      () => ep.createProducer().send(makeExchange({ x: 1 })),
+      /cannot resolve datasource 'ghost'/i
+    );
+  });
+
+  it('throws when no name given and context has multiple beans', async () => {
+    const comp = new NosqlComponent();
+    const ctx = new CamelContext();
+    ctx.registerBean('ds1', makeDs());
+    ctx.registerBean('ds2', makeDs()); // two beans — no auto-select
+
+    const params = new URLSearchParams('operation=insert');
+    const ep = comp.createEndpoint('nosql:col?operation=insert', 'col', params, ctx);
+
+    await assert.rejects(
+      () => ep.createProducer().send(makeExchange({ x: 1 })),
+      /cannot resolve datasource/i
+    );
+  });
+});