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

package/README.md

@@ -0,0 +1,64 @@
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## What
+
+SQL query and update producer using Node.js built-in [`node:sqlite`](https://nodejs.org/api/sqlite.html) — no native compilation required. The SQL statement is placed in the URI path (URL-encoded). Query results are set as the exchange body; for updates the row-change count is set.
+
+> **Requires Node.js 22.5.0 or later.** Uses `node:sqlite` (DatabaseSync / StatementSync). No `better-sqlite3` or other native dependency.
+
+## Install
+
+```sh
+npm install camel-lite-component-sql
+```
+
+## URI Syntax
+
+```
+sql:<URL-encoded SQL>[?url=jdbc:sqlite::memory:]
+```
+
+URL-encode spaces as `+` in the SQL statement.
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `url`     | *(required)* | SQLite connection URL. Format: `jdbc:sqlite:<file-path>` or `jdbc:sqlite::memory:` for in-memory. |
+
+## Usage
+
+```js
+import { CamelContext } from 'camel-lite-core';
+import { SqlComponent } from 'camel-lite-component-sql';
+
+const context = new CamelContext();
+context.addComponent('sql', new SqlComponent());
+
+context.addRoutes({
+  configure(ctx) {
+    // Insert: exchange body provides the bound parameter value
+    ctx.from('direct:logEvent')
+      .to('sql:INSERT+INTO+events+(message)+VALUES+(?)?url=jdbc:sqlite:/tmp/events.db');
+
+    // Query: results returned as array of row objects
+    ctx.from('direct:fetchEvents')
+      .to('sql:SELECT+*+FROM+events?url=jdbc:sqlite:/tmp/events.db');
+  }
+});
+
+await context.start();
+
+const template = context.createProducerTemplate();
+
+// Insert
+await template.sendBody('direct:logEvent', 'something happened');
+
+// Query
+const exchange = await template.send('direct:fetchEvents', ex => { ex.in.body = []; });
+console.log('Rows:', 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-sql",
+  "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",
+    "sql",
+    "sqlite",
+    "database",
+    "component"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/src/ParameterBinder.js

@@ -0,0 +1,63 @@
+/**
+ * ParameterBinder — normalises named `:param` placeholders to driver-specific syntax.
+ *
+ * Supported dialects:
+ *   'pg'      → $1, $2, ...  (positional, params returned as array)
+ *   'mysql2'  → ?, ?, ...    (positional, params returned as array)
+ *   'sqlite'  → ?, ?, ...    (positional, params returned as array)
+ *   'named'   → :param       (pass-through, params returned as object)
+ *
+ * Input template uses :paramName placeholders:
+ *   SELECT * FROM users WHERE id = :id AND status = :status
+ *
+ * Params are sourced from (in order):
+ *   1. exchange.in.body  if it is a plain object
+ *   2. exchange.in.headers (as key→value Map)
+ *   3. Empty object if neither is a plain object
+ */
+export const ParameterBinder = {
+  /**
+   * Extract bind params from the exchange.
+   * @param {import('@alt-javascript/camel-lite-core').Exchange} exchange
+   * @returns {object}  key→value map
+   */
+  extractParams(exchange) {
+    const body = exchange.in.body;
+    if (body !== null && typeof body === 'object' && !Array.isArray(body)) {
+      return body;
+    }
+    // Fallback: collect all headers as params
+    const params = {};
+    if (exchange.in.headers instanceof Map) {
+      for (const [k, v] of exchange.in.headers) {
+        params[k] = v;
+      }
+    }
+    return params;
+  },
+
+  /**
+   * Replace :paramName placeholders according to the dialect.
+   * @param {string} template  - SQL with :paramName placeholders
+   * @param {object} params    - key→value map of bind values
+   * @param {'pg'|'mysql2'|'sqlite'|'named'} dialect
+   * @returns {{ sql: string, values: Array|object }}
+   */
+  replaceParams(template, params, dialect = 'sqlite') {
+    if (dialect === 'named') {
+      return { sql: template, values: params };
+    }
+
+    const values = [];
+    let counter = 0;
+    const sql = template.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, name) => {
+      values.push(params[name] ?? null);
+      counter++;
+      return dialect === 'pg' ? `$${counter}` : '?';
+    });
+
+    return { sql, values };
+  },
+};
+
+export default ParameterBinder;

package/src/SqlComponent.js

@@ -0,0 +1,118 @@
+import { Component } from '@alt-javascript/camel-lite-core';
+import { LoggerFactory } from '@alt-javascript/logger';
+import { SqlEndpoint } from './SqlEndpoint.js';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/SqlComponent');
+
+/**
+ * SqlComponent — executes SQL queries as a pipeline step.
+ *
+ * Datasource resolution (three-step chain, evaluated at send() time):
+ *
+ *   1. Component-internal map  — setDatasource(name, factory) takes priority.
+ *      Name comes from: ?datasource= URI param, then the sql: path segment.
+ *
+ *   2. Context bean by name    — context.getBean(name) is checked when the
+ *      component map has no match. The bean is the datasource object directly
+ *      (not a factory wrapper).
+ *
+ *   3. Auto-select             — when no explicit name is given (or the named
+ *      lookup found nothing) and context.getBeans() has exactly one entry,
+ *      that bean is used automatically.
+ *
+ * setDatasource() registers a factory (zero-arg fn → db connection/pool).
+ * Context beans are registered directly: context.registerBean('myDb', db).
+ *
+ * URI formats (all equivalent):
+ *   sql:myDsName?query=SELECT+1&dialect=sqlite          ← path segment as ds name
+ *   sql:?datasource=myDsBean&query=SELECT+1             ← explicit param (overrides path)
+ *   sql:?query=SELECT+1&dialect=sqlite                  ← auto-select when 1 bean in ctx
+ *
+ * Supported driver shapes (communicated via 'dialect' URI param, default 'sqlite'):
+ *   'sqlite'  → node:sqlite (DatabaseSync) — synchronous
+ *   'pg'      → pg Pool — async: pool.query(sql, values)
+ *   'mysql2'  → mysql2 Pool — async: pool.query(sql, values)
+ *   'named'   → node:sqlite with pass-through named params
+ */
+class SqlComponent extends Component {
+  #datasources = new Map();   // name → factory function (explicit component-level registration)
+  #endpoints = new Map();
+
+  /**
+   * Register a named datasource factory on the component.
+   * This takes priority over context bean lookup.
+   * @param {string} name
+   * @param {function} factory  - () => db/pool connection
+   */
+  setDatasource(name, factory) {
+    this.#datasources.set(name, factory);
+    log.info(`SqlComponent: datasource '${name}' registered on component`);
+    return this;
+  }
+
+  /**
+   * Resolve a datasource connection using the three-step chain.
+   * @param {string|null} name      - bean/datasource name, or null for auto-select
+   * @param {CamelContext|null} context
+   * @returns {*} the database connection/pool
+   */
+  getDatasource(name, context = null) {
+    // Step 1: component-internal map
+    if (name && this.#datasources.has(name)) {
+      log.debug(`SqlComponent: datasource '${name}' resolved from component map`);
+      return this.#datasources.get(name)();
+    }
+
+    if (context) {
+      // Step 2: context bean by name
+      if (name) {
+        const bean = context.getBean(name);
+        if (bean != null) {
+          log.debug(`SqlComponent: datasource '${name}' resolved from context bean`);
+          return bean;
+        }
+      }
+
+      // Step 3: single-bean auto-select
+      const allBeans = context.getBeans();
+      if (allBeans.length === 1) {
+        log.debug(`SqlComponent: datasource auto-selected (single bean in context: '${allBeans[0][0]}')`);
+        return allBeans[0][1];
+      }
+    }
+
+    throw new Error(
+      `SqlComponent: cannot resolve datasource '${name ?? '(none)'}'. ` +
+      `Register via component.setDatasource(), context.registerBean(), ` +
+      `or ensure exactly one bean is registered in context.`
+    );
+  }
+
+  createEndpoint(uri, remaining, parameters, context) {
+    if (this.#endpoints.has(uri)) {
+      return this.#endpoints.get(uri);
+    }
+
+    // ?datasource= param takes priority over the path segment as the ds name.
+    // Either may be absent — null triggers auto-select at send() time.
+    const pathName = remaining.replace(/^\/+/, '') || null;
+    const datasourceName = parameters.get('datasource') ?? pathName;
+
+    const query = parameters.get('query') ?? '';
+    const outputType = parameters.get('outputType') ?? 'rows';
+    const dialect = parameters.get('dialect') ?? 'sqlite';
+
+    if (!query) {
+      throw new Error(`SqlEndpoint: 'query' parameter is required on URI: ${uri}`);
+    }
+
+    log.info(`SqlComponent creating endpoint: ds=${datasourceName ?? '(auto)'}, dialect=${dialect}, outputType=${outputType}`);
+
+    const endpoint = new SqlEndpoint(uri, datasourceName, query, outputType, dialect, context, this);
+    this.#endpoints.set(uri, endpoint);
+    return endpoint;
+  }
+}
+
+export { SqlComponent };
+export default SqlComponent;

package/src/SqlConsumer.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/SqlConsumer');
+
+/**
+ * SqlConsumer — stub implementation.
+ * sql: is primarily producer-oriented (execute SQL on-demand as a pipeline step).
+ * A scheduled poll consumer (timer-driven SELECT) is deferred to a future milestone.
+ */
+class SqlConsumer 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(`SqlConsumer started: ${uri}`);
+  }
+
+  async stop() {
+    const { uri, context } = this.#endpoint;
+    context.registerConsumer(uri, null);
+    log.info(`SqlConsumer stopped: ${uri}`);
+  }
+
+  async process(exchange) {
+    return this.#pipeline.run(exchange);
+  }
+}
+
+export { SqlConsumer };
+export default SqlConsumer;

package/src/SqlEndpoint.js

@@ -0,0 +1,53 @@
+import { Endpoint } from '@alt-javascript/camel-lite-core';
+import { SqlProducer } from './SqlProducer.js';
+import { SqlConsumer } from './SqlConsumer.js';
+
+/**
+ * SqlEndpoint holds the parsed URI state for a sql: endpoint.
+ *
+ * URI format:
+ *   sql:datasourceName?query=SELECT+*+FROM+users&outputType=rows&dialect=sqlite
+ *
+ * outputType: 'rows'     (default) → sets exchange.in.body = array of row objects
+ *             'rowCount' → sets exchange.in.body = { rowCount: N }
+ * dialect:    'sqlite' (default) | 'pg' | 'mysql2' | 'named'
+ */
+class SqlEndpoint extends Endpoint {
+  #uri;
+  #datasourceName;
+  #query;
+  #outputType;
+  #dialect;
+  #context;
+  #component;
+
+  constructor(uri, datasourceName, query, outputType, dialect, context, component) {
+    super();
+    this.#uri = uri;
+    this.#datasourceName = datasourceName;
+    this.#query = query;
+    this.#outputType = outputType;
+    this.#dialect = dialect;
+    this.#context = context;
+    this.#component = component;
+  }
+
+  get uri() { return this.#uri; }
+  get datasourceName() { return this.#datasourceName; }
+  get query() { return this.#query; }
+  get outputType() { return this.#outputType; }
+  get dialect() { return this.#dialect; }
+  get context() { return this.#context; }
+  get component() { return this.#component; }
+
+  createProducer() {
+    return new SqlProducer(this);
+  }
+
+  createConsumer(pipeline) {
+    return new SqlConsumer(this, pipeline);
+  }
+}
+
+export { SqlEndpoint };
+export default SqlEndpoint;

package/src/SqlProducer.js

@@ -0,0 +1,86 @@
+import { Producer } from '@alt-javascript/camel-lite-core';
+import { LoggerFactory } from '@alt-javascript/logger';
+import { ParameterBinder } from './ParameterBinder.js';
+
+const log = LoggerFactory.getLogger('@alt-javascript/camel-lite/SqlProducer');
+
+/**
+ * SqlProducer — executes the endpoint's SQL query against the registered datasource.
+ *
+ * Result mapping:
+ *   SELECT (outputType='rows')     → exchange.in.body = array of row objects
+ *   INSERT/UPDATE/DELETE           → exchange.in.body = { rowCount: N }
+ *   outputType='rowCount' forced   → exchange.in.body = { rowCount: N }
+ *
+ * Driver detection (via endpoint.dialect):
+ *   'sqlite'  → better-sqlite3 sync API: db.prepare(sql).all(values) / .run(values)
+ *   'pg'      → pg async API: pool.query(sql, values) → { rows, rowCount }
+ *   'mysql2'  → mysql2 async API: pool.query(sql, values) → [rows, fields]
+ *   'named'   → better-sqlite3 named API: db.prepare(sql).all(namedObj)
+ */
+class SqlProducer extends Producer {
+  #endpoint;
+
+  constructor(endpoint) {
+    super();
+    this.#endpoint = endpoint;
+  }
+
+  async send(exchange) {
+    const { datasourceName, query, outputType, dialect, component, context } = this.#endpoint;
+
+    const db = component.getDatasource(datasourceName, context);
+    const params = ParameterBinder.extractParams(exchange);
+    const { sql, values } = ParameterBinder.replaceParams(query, params, dialect);
+
+    log.debug(`SqlProducer [${dialect}] executing: ${sql}`);
+
+    let result;
+    if (dialect === 'sqlite' || dialect === 'named') {
+      result = await SqlProducer.#execSqlite(db, sql, values, outputType);
+    } else if (dialect === 'pg') {
+      result = await SqlProducer.#execPg(db, sql, values, outputType);
+    } else if (dialect === 'mysql2') {
+      result = await SqlProducer.#execMysql2(db, sql, values, outputType);
+    } else {
+      throw new Error(`SqlProducer: unknown dialect '${dialect}'`);
+    }
+
+    exchange.in.body = result;
+    log.debug(`SqlProducer done: outputType=${outputType}`);
+  }
+
+  static async #execSqlite(db, sql, values, outputType) {
+    const stmt = db.prepare(sql);
+    const sqlTrimmed = sql.trimStart().toUpperCase();
+    const isSelect = sqlTrimmed.startsWith('SELECT') || sqlTrimmed.startsWith('WITH');
+
+    if (outputType === 'rows' && isSelect) {
+      // node:sqlite StatementSync.all() takes spread args, not an array.
+      // We spread values so both [] and [...items] forms work.
+      return stmt.all(...(Array.isArray(values) ? values : Object.values(values)));
+    } else {
+      const info = stmt.run(...(Array.isArray(values) ? values : Object.values(values)));
+      return { rowCount: info.changes };
+    }
+  }
+
+  static async #execPg(pool, sql, values, outputType) {
+    const result = await pool.query(sql, values);
+    if (outputType === 'rows') {
+      return result.rows;
+    }
+    return { rowCount: result.rowCount };
+  }
+
+  static async #execMysql2(pool, sql, values, outputType) {
+    const [rows] = await pool.query(sql, values);
+    if (outputType === 'rows' && Array.isArray(rows)) {
+      return rows;
+    }
+    return { rowCount: rows.affectedRows ?? 0 };
+  }
+}
+
+export { SqlProducer };
+export default SqlProducer;

package/src/SqliteClientFactory.js

@@ -0,0 +1,20 @@
+import { DatabaseSync } from 'node:sqlite';
+
+/**
+ * SQLite factory using Node's built-in node:sqlite module (Node 22.5+).
+ * No native compile required — uses V8's built-in SQLite support.
+ *
+ * Note: node:sqlite is marked experimental in Node 22/24 but is stable enough
+ * for our use case. No external dependency needed.
+ */
+
+/**
+ * Open an in-memory or file-based SQLite database.
+ * @param {string} path  - ':memory:' or a file path
+ * @returns {import('node:sqlite').DatabaseSync}
+ */
+export function openDatabase(path = ':memory:') {
+  return new DatabaseSync(path);
+}
+
+export { DatabaseSync };

package/src/index.js

@@ -0,0 +1,6 @@
+export { SqlComponent } from './SqlComponent.js';
+export { SqlEndpoint } from './SqlEndpoint.js';
+export { SqlProducer } from './SqlProducer.js';
+export { SqlConsumer } from './SqlConsumer.js';
+export { ParameterBinder } from './ParameterBinder.js';
+export { openDatabase } from './SqliteClientFactory.js';

package/test/sql.test.js

@@ -0,0 +1,397 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { DatabaseSync } from 'node:sqlite';
+import { Exchange, CamelContext } from '@alt-javascript/camel-lite-core';
+import { SqlComponent, ParameterBinder, openDatabase } from '@alt-javascript/camel-lite-component-sql';
+
+// ---------------------------------------------------------------------------
+// Helper: open an in-memory SQLite DB with a test table
+// ---------------------------------------------------------------------------
+function makeDb() {
+  const db = new DatabaseSync(':memory:');
+  db.exec(`
+    CREATE TABLE items (
+      id   INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      qty  INTEGER NOT NULL DEFAULT 0
+    )
+  `);
+  db.prepare('INSERT INTO items (name, qty) VALUES (?, ?)').run('apple', 10);
+  db.prepare('INSERT INTO items (name, qty) VALUES (?, ?)').run('banana', 5);
+  db.prepare('INSERT INTO items (name, qty) VALUES (?, ?)').run('cherry', 20);
+  return db;
+}
+
+function makeExchange(body) {
+  const ex = new Exchange();
+  ex.in.body = body;
+  return ex;
+}
+
+// ---------------------------------------------------------------------------
+// ParameterBinder unit tests
+// ---------------------------------------------------------------------------
+
+describe('ParameterBinder', () => {
+  it('replaceParams: sqlite dialect replaces :name with ?', () => {
+    const { sql, values } = ParameterBinder.replaceParams(
+      'SELECT * FROM items WHERE name = :name AND qty > :qty',
+      { name: 'apple', qty: 5 },
+      'sqlite'
+    );
+    assert.equal(sql, 'SELECT * FROM items WHERE name = ? AND qty > ?');
+    assert.deepEqual(values, ['apple', 5]);
+  });
+
+  it('replaceParams: pg dialect replaces :name with $1, $2', () => {
+    const { sql, values } = ParameterBinder.replaceParams(
+      'SELECT * FROM users WHERE id = :id AND role = :role',
+      { id: 42, role: 'admin' },
+      'pg'
+    );
+    assert.equal(sql, 'SELECT * FROM users WHERE id = $1 AND role = $2');
+    assert.deepEqual(values, [42, 'admin']);
+  });
+
+  it('replaceParams: mysql2 dialect replaces :name with ?', () => {
+    const { sql, values } = ParameterBinder.replaceParams(
+      'UPDATE t SET status = :status WHERE id = :id',
+      { status: 'active', id: 7 },
+      'mysql2'
+    );
+    assert.equal(sql, 'UPDATE t SET status = ? WHERE id = ?');
+    assert.deepEqual(values, ['active', 7]);
+  });
+
+  it('replaceParams: named dialect passes through unchanged', () => {
+    const template = 'SELECT * FROM t WHERE x = :x';
+    const params = { x: 99 };
+    const { sql, values } = ParameterBinder.replaceParams(template, params, 'named');
+    assert.equal(sql, template);
+    assert.equal(values, params);
+  });
+
+  it('replaceParams: missing param defaults to null', () => {
+    const { values } = ParameterBinder.replaceParams(
+      'SELECT * FROM t WHERE a = :a AND b = :b',
+      { a: 1 }, // b is missing
+      'sqlite'
+    );
+    assert.deepEqual(values, [1, null]);
+  });
+
+  it('extractParams: returns body if it is a plain object', () => {
+    const ex = makeExchange({ id: 5, name: 'pear' });
+    assert.deepEqual(ParameterBinder.extractParams(ex), { id: 5, name: 'pear' });
+  });
+
+  it('extractParams: falls back to headers if body is not an object', () => {
+    const ex = makeExchange('string body');
+    ex.in.setHeader('id', 42);
+    const params = ParameterBinder.extractParams(ex);
+    assert.equal(params.id, 42);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// SqlComponent + SqlProducer — SELECT
+// ---------------------------------------------------------------------------
+
+describe('SqlProducer: SELECT', () => {
+  it('executes SELECT and sets rows array on exchange.in.body', async () => {
+    const db = makeDb();
+    const comp = new SqlComponent();
+    comp.setDatasource('default', () => db);
+
+    const ctx = new CamelContext();
+    const params = new URLSearchParams('query=SELECT+*+FROM+items&dialect=sqlite');
+    const ep = comp.createEndpoint('sql:default?query=SELECT+*+FROM+items&dialect=sqlite', 'default', params, ctx);
+    const producer = ep.createProducer();
+
+    const ex = makeExchange(null);
+    await producer.send(ex);
+
+    assert.ok(Array.isArray(ex.in.body), 'body should be an array');
+    assert.equal(ex.in.body.length, 3);
+    assert.equal(ex.in.body[0].name, 'apple');
+    assert.equal(ex.in.body[1].name, 'banana');
+  });
+
+  it('executes parameterized SELECT with :name placeholders', async () => {
+    const db = makeDb();
+    const comp = new SqlComponent();
+    comp.setDatasource('myds', () => db);
+
+    const ctx = new CamelContext();
+    const q = 'SELECT+*+FROM+items+WHERE+name+=+:name';
+    const params = new URLSearchParams(`query=${q}&dialect=sqlite`);
+    const ep = comp.createEndpoint(`sql:myds?query=${q}&dialect=sqlite`, 'myds', params, ctx);
+    const producer = ep.createProducer();
+
+    const ex = makeExchange({ name: 'cherry' });
+    await producer.send(ex);
+
+    assert.equal(ex.in.body.length, 1);
+    assert.equal(ex.in.body[0].qty, 20);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// SqlProducer — INSERT / UPDATE / DELETE
+// ---------------------------------------------------------------------------
+
+describe('SqlProducer: mutations', () => {
+  it('INSERT returns { rowCount: 1 }', async () => {
+    const db = makeDb();
+    const comp = new SqlComponent();
+    comp.setDatasource('default', () => db);
+
+    const ctx = new CamelContext();
+    const q = encodeURIComponent('INSERT INTO items (name, qty) VALUES (:name, :qty)');
+    const params = new URLSearchParams(`query=${q}&dialect=sqlite&outputType=rowCount`);
+    const ep = comp.createEndpoint(`sql:default?query=${q}&dialect=sqlite&outputType=rowCount`, 'default', params, ctx);
+    const producer = ep.createProducer();
+
+    const ex = makeExchange({ name: 'grape', qty: 7 });
+    await producer.send(ex);
+
+    assert.deepEqual(ex.in.body, { rowCount: 1 });
+
+    // Confirm row was inserted
+    const rows = db.prepare('SELECT * FROM items WHERE name = ?').all('grape');
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].qty, 7);
+  });
+
+  it('UPDATE returns { rowCount: N }', async () => {
+    const db = makeDb();
+    const comp = new SqlComponent();
+    comp.setDatasource('default', () => db);
+
+    const ctx = new CamelContext();
+    const q = encodeURIComponent('UPDATE items SET qty = :qty WHERE name = :name');
+    const params = new URLSearchParams(`query=${q}&dialect=sqlite&outputType=rowCount`);
+    const ep = comp.createEndpoint(`sql:default?query=${q}&dialect=sqlite&outputType=rowCount`, 'default', params, ctx);
+    const producer = ep.createProducer();
+
+    const ex = makeExchange({ name: 'apple', qty: 99 });
+    await producer.send(ex);
+
+    assert.deepEqual(ex.in.body, { rowCount: 1 });
+    const rows = db.prepare('SELECT qty FROM items WHERE name = ?').all('apple');
+    assert.equal(rows[0].qty, 99);
+  });
+
+  it('DELETE returns { rowCount: N }', async () => {
+    const db = makeDb();
+    const comp = new SqlComponent();
+    comp.setDatasource('default', () => db);
+
+    const ctx = new CamelContext();
+    const q = encodeURIComponent('DELETE FROM items WHERE name = :name');
+    const params = new URLSearchParams(`query=${q}&dialect=sqlite&outputType=rowCount`);
+    const ep = comp.createEndpoint(`sql:default?query=${q}&dialect=sqlite&outputType=rowCount`, 'default', params, ctx);
+    const producer = ep.createProducer();
+
+    const ex = makeExchange({ name: 'banana' });
+    await producer.send(ex);
+
+    assert.deepEqual(ex.in.body, { rowCount: 1 });
+    const remaining = db.prepare('SELECT COUNT(*) as cnt FROM items').all();
+    assert.equal(remaining[0].cnt, 2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Multiple named datasources
+// ---------------------------------------------------------------------------
+
+describe('SqlComponent: multiple named datasources', () => {
+  it('routes queries to the correct named datasource', async () => {
+    const db1 = new DatabaseSync(':memory:');
+    db1.exec('CREATE TABLE t (val TEXT)');
+    db1.prepare('INSERT INTO t (val) VALUES (?)').run('from-db1');
+
+    const db2 = new DatabaseSync(':memory:');
+    db2.exec('CREATE TABLE t (val TEXT)');
+    db2.prepare('INSERT INTO t (val) VALUES (?)').run('from-db2');
+
+    const comp = new SqlComponent();
+    comp.setDatasource('ds1', () => db1);
+    comp.setDatasource('ds2', () => db2);
+
+    const ctx = new CamelContext();
+
+    const params1 = new URLSearchParams('query=SELECT+val+FROM+t&dialect=sqlite');
+    const ep1 = comp.createEndpoint('sql:ds1?query=SELECT+val+FROM+t&dialect=sqlite', 'ds1', params1, ctx);
+
+    const params2 = new URLSearchParams('query=SELECT+val+FROM+t&dialect=sqlite');
+    const ep2 = comp.createEndpoint('sql:ds2?query=SELECT+val+FROM+t&dialect=sqlite', 'ds2', params2, ctx);
+
+    const ex1 = makeExchange(null);
+    await ep1.createProducer().send(ex1);
+    assert.equal(ex1.in.body[0].val, 'from-db1');
+
+    const ex2 = makeExchange(null);
+    await ep2.createProducer().send(ex2);
+    assert.equal(ex2.in.body[0].val, 'from-db2');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// SqlComponent: missing datasource throws
+// ---------------------------------------------------------------------------
+
+describe('SqlComponent: error cases', () => {
+  it('throws when query param is missing', () => {
+    const comp = new SqlComponent();
+    comp.setDatasource('default', () => null);
+    const ctx = new CamelContext();
+    const params = new URLSearchParams('dialect=sqlite'); // no query
+    assert.throws(
+      () => comp.createEndpoint('sql:default?dialect=sqlite', 'default', params, ctx),
+      /query.*required/i
+    );
+  });
+
+  it('throws when datasource is not registered', async () => {
+    const comp = new SqlComponent();
+    const ctx = new CamelContext();
+    const params = new URLSearchParams('query=SELECT+1&dialect=sqlite');
+    const ep = comp.createEndpoint('sql:unknown?query=SELECT+1&dialect=sqlite', 'unknown', params, ctx);
+    const producer = ep.createProducer();
+    await assert.rejects(
+      () => producer.send(makeExchange(null)),
+      /cannot resolve datasource 'unknown'/i
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// openDatabase helper
+// ---------------------------------------------------------------------------
+
+describe('openDatabase helper', () => {
+  it('opens an in-memory SQLite database', () => {
+    const db = openDatabase(':memory:');
+    assert.ok(db, 'should return a DatabaseSync instance');
+    db.exec('CREATE TABLE t (x INTEGER)');
+    db.prepare('INSERT INTO t (x) VALUES (?)').run(42);
+    const rows = db.prepare('SELECT x FROM t').all();
+    assert.equal(rows[0].x, 42);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Context-aware datasource resolution (three-step chain)
+// ---------------------------------------------------------------------------
+
+describe('SqlComponent: context bean resolution', () => {
+  function makeDb() {
+    const db = new DatabaseSync(':memory:');
+    db.exec('CREATE TABLE t (id INTEGER PRIMARY KEY AUTOINCREMENT, val TEXT)');
+    db.prepare('INSERT INTO t (val) VALUES (?)').run('hello');
+    return db;
+  }
+
+  it('step 2: resolves datasource from context.getBean(name) when not in component map', async () => {
+    const db = makeDb();
+    const comp = new SqlComponent(); // no setDatasource()
+    const ctx = new CamelContext();
+    ctx.registerBean('myDb', db);
+
+    const params = new URLSearchParams('datasource=myDb&query=SELECT+val+FROM+t&dialect=sqlite');
+    const ep = comp.createEndpoint('sql:?datasource=myDb&query=SELECT+val+FROM+t&dialect=sqlite', '', params, ctx);
+
+    const ex = new Exchange();
+    ex.in.body = null;
+    await ep.createProducer().send(ex);
+
+    assert.ok(Array.isArray(ex.in.body));
+    assert.equal(ex.in.body[0].val, 'hello');
+  });
+
+  it('step 3: auto-selects single context bean when no name given', async () => {
+    const db = makeDb();
+    const comp = new SqlComponent();
+    const ctx = new CamelContext();
+    ctx.registerBean('theOnlyDb', db); // only one bean
+
+    const params = new URLSearchParams('query=SELECT+val+FROM+t&dialect=sqlite');
+    const ep = comp.createEndpoint('sql:?query=SELECT+val+FROM+t&dialect=sqlite', '', params, ctx);
+
+    const ex = new Exchange();
+    ex.in.body = null;
+    await ep.createProducer().send(ex);
+
+    assert.ok(Array.isArray(ex.in.body));
+    assert.equal(ex.in.body[0].val, 'hello');
+  });
+
+  it('step 1 takes priority over context bean when component map has same name', async () => {
+    const dbInMap = makeDb();
+    dbInMap.exec('INSERT INTO t (val) VALUES (?)', 'from-map');
+
+    const dbInContext = makeDb();
+
+    const comp = new SqlComponent();
+    comp.setDatasource('myDb', () => dbInMap); // component map — takes priority
+
+    const ctx = new CamelContext();
+    ctx.registerBean('myDb', dbInContext); // context — should be ignored
+
+    const params = new URLSearchParams('datasource=myDb&query=SELECT+COUNT(*)+AS+cnt+FROM+t&dialect=sqlite');
+    const ep = comp.createEndpoint('sql:?datasource=myDb&query=SELECT+COUNT(*)+AS+cnt+FROM+t&dialect=sqlite', '', params, ctx);
+
+    const ex = new Exchange();
+    ex.in.body = null;
+    await ep.createProducer().send(ex);
+
+    // dbInMap has 2 rows (original + 'from-map'), dbInContext has 1
+    assert.equal(ex.in.body[0].cnt, 2);
+  });
+
+  it('?datasource= param overrides the sql: path segment as the name', async () => {
+    const db = makeDb();
+    const comp = new SqlComponent();
+    const ctx = new CamelContext();
+    ctx.registerBean('paramBean', db);
+
+    // Path says 'pathBean' but ?datasource= says 'paramBean'
+    const params = new URLSearchParams('datasource=paramBean&query=SELECT+val+FROM+t&dialect=sqlite');
+    const ep = comp.createEndpoint('sql:pathBean?datasource=paramBean&query=SELECT+val+FROM+t&dialect=sqlite', 'pathBean', params, ctx);
+
+    const ex = new Exchange();
+    ex.in.body = null;
+    await ep.createProducer().send(ex);
+
+    assert.equal(ex.in.body[0].val, 'hello');
+  });
+
+  it('throws a descriptive error when no resolution path succeeds', async () => {
+    const comp = new SqlComponent();
+    const ctx = new CamelContext(); // no beans
+    const params = new URLSearchParams('datasource=ghost&query=SELECT+1&dialect=sqlite');
+    const ep = comp.createEndpoint('sql:?datasource=ghost&query=SELECT+1&dialect=sqlite', '', params, ctx);
+
+    await assert.rejects(
+      () => ep.createProducer().send(new Exchange()),
+      /cannot resolve datasource 'ghost'/i
+    );
+  });
+
+  it('throws when no name given and context has zero or multiple beans', async () => {
+    const comp = new SqlComponent();
+    const ctx = new CamelContext();
+    ctx.registerBean('db1', makeDb());
+    ctx.registerBean('db2', makeDb()); // two beans — no auto-select
+
+    const params = new URLSearchParams('query=SELECT+1&dialect=sqlite');
+    const ep = comp.createEndpoint('sql:?query=SELECT+1&dialect=sqlite', '', params, ctx);
+
+    await assert.rejects(
+      () => ep.createProducer().send(new Exchange()),
+      /cannot resolve datasource/i
+    );
+  });
+});