fix(service-datasource): Test keeps its answer's existing keys; the changeset declares the liveDriver widening

A driver without introspectSchema answers its health probe as
{ ok, latencyMs } with no tableCount, like the primary datasource: the
`introspection` key is dropped, since nothing reads it. The changeset is a
minor bump with Clause-② yes, naming the one published-surface addition,
the optional ExternalDatasourceServiceConfig.liveDriver callback.

Claude-Session: https://claude.ai/code/session_01UmqzD97e14iws6hmVhgZ5y
Co-authored-by: Claude <noreply@anthropic.com>

Author: claude

.changeset/24772-primary-datasource-test-sync.md

@@ -1,14 +1,15 @@
 ---
-'@objectstack/service-datasource': patch
+'@objectstack/service-datasource': minor
 ---
 
 fix(service-datasource): Setup → Datasources: Test answers truthfully for the platform's primary datasource and for drivers that cannot introspect, and Sync on the primary datasource refuses with the true reason
 
-Clause-②: no (no status code, error code or accepted value moves on any route; Test's answer gains one optional key, `introspection: 'unsupported'`, and `ExternalDatasourceServiceConfig` one optional member, `liveDriver`)
+Clause-②: yes (widening: the published `ExternalDatasourceServiceConfig`, exported from the package entry, gains one optional member, the `liveDriver` callback; no status code, error code or accepted value moves on any route, and Test's answer keeps its existing keys)
 
 - **What was wrong.** The Datasources page listed the primary datasource (`default`) as connected, which is true. Its Test then answered `200 { ok: false }` and Sync answered `400`, both saying the datasource "has no registered driver to introspect". The primary datasource's driver is registered under the driver's own name, not under `default`, and both doors looked it up by `default`. A connected `memory` datasource also got `ok: false` from Test, because Test was an introspection round trip and that driver cannot introspect.
-- **Test, `POST /api/v1/datasources/:name/test`.** For the primary datasource, Test now finds the live driver the way the connection service's own teardown does and answers its health check: `{ ok: true, latencyMs }`. It does not list the platform database's tables. For a driver with no schema introspection (`memory`, `mongodb`), Test answers the health check too and says `introspection: 'unsupported'`, instead of `ok: false`. A driver that fails its health check answers `ok: false`. Every other datasource is tested exactly as before (an introspection round trip with `tableCount`), and so is a datasource with no live driver.
+- **Test, `POST /api/v1/datasources/:name/test`.** For the primary datasource, Test now finds the live driver the way the connection service's own teardown does and answers its health check: `{ ok: true, latencyMs }`. It does not list the platform database's tables. For a driver with no schema introspection (`memory`, `mongodb`), Test answers the health check too, `{ ok: true, latencyMs }` with no `tableCount`, instead of `ok: false`. A driver that fails its health check answers `ok: false`. Every other datasource is tested exactly as before (an introspection round trip with `tableCount`), and so is a datasource with no live driver.
 - **Sync on the primary datasource.** `GET …/remote-tables`, `POST …/object-draft`, the import (`POST …/external/tables/:remote/import`) and the catalog refresh still refuse `default`, with the same status and code as before (`400 EXTERNAL_DATASOURCE_ERROR`, or `EXTERNAL_IMPORT_ERROR` on the import). The message now gives the true reason: the primary datasource is the platform's managed storage, not a federation source, so there are no remote tables to list, draft or import from it. Its tables are never introspected.
 - **Unchanged.** Sync on every other datasource, including a managed runtime one, answers exactly as before.
+- **New, optional: `ExternalDatasourceServiceConfig.liveDriver`.** `(datasource) => driver | undefined` returns the live driver registered for a datasource, resolved by the primary datasource's naming rule. `ExternalDatasourceServicePlugin` wires it. Test reads it to reach the primary datasource and drivers without schema introspection.
 
-What to do: nothing. If you build `ExternalDatasourceService` yourself, wire `liveDriver` to get the new Test answers; without it, Test stays the introspection round trip.
+What to do: nothing, if the plugin builds the service. If you build `ExternalDatasourceService` yourself, pass `liveDriver` to get the new Test answers; without it, Test stays the introspection round trip, as before.

packages/services/service-datasource/src/__tests__/primary-datasource-test-and-sync.test.ts

@@ -16,8 +16,10 @@
  *
  *  - Test answers truthfully for both. The primary datasource's driver is
  *    found by the resolver `DatasourceConnectionService.disconnect` already
- *    applies (`registeredDriverName`), and a driver that cannot introspect says
- *    so instead of failing.
+ *    applies (`registeredDriverName`), and a driver that cannot introspect
+ *    answers its health probe instead of failing. Both answer the existing
+ *    `{ ok, latencyMs }` keys and nothing more (the seat's REWORK record:
+ *    no answer key without a consumer).
  *  - Sync on `default` keeps refusing with the SAME status and code, and now
  *    gives the true reason: the primary datasource is the platform's managed
  *    storage, not a federation source (ADR-0015 §1). It never introspects the
@@ -162,10 +164,11 @@ describe('the primary datasource: Test agrees with the "connected" the page list
     expect(test.status).toBe(200);
     expect(test.body.data).toMatchObject({ ok: true });
     expect(typeof test.body.data.latencyMs).toBe('number');
-    expect(test.body.data).not.toHaveProperty('error');
     // The primary datasource is not a federation source: Test asks the driver
     // whether it is connected, never lists the platform's tables to find out.
-    expect(test.body.data).not.toHaveProperty('tableCount');
+    // So the answer is the existing keys `ok` and `latencyMs`, with no
+    // `tableCount` and no `error`.
+    expect(Object.keys(test.body.data).sort()).toEqual(['latencyMs', 'ok']);
     expect(introspect).not.toHaveBeenCalled();
   });
 });
@@ -202,13 +205,16 @@ describe('the primary datasource: Sync refuses as before, with the true reason',
 });
 
 describe('a driver with no introspectSchema', () => {
-  it('Test answers connected and says introspection is unsupported, instead of ok: false', async () => {
+  it('Test answers its health probe, connected, instead of ok: false', async () => {
     const { call } = await boot();
 
     const test = await call('POST', '/scratch/test');
     expect(test.status).toBe(200);
-    expect(test.body.data).toMatchObject({ ok: true, introspection: 'unsupported' });
-    expect(test.body.data).not.toHaveProperty('error');
+    expect(test.body.data).toMatchObject({ ok: true });
+    expect(typeof test.body.data.latencyMs).toBe('number');
+    // The answer's existing keys, and no other: no `tableCount` (it cannot list
+    // tables), no `error`, and no key invented to say why.
+    expect(Object.keys(test.body.data).sort()).toEqual(['latencyMs', 'ok']);
   });
 
   it('a registered driver that fails its health check is not reported connected', async () => {
@@ -241,7 +247,6 @@ describe('nothing else moves', () => {
     const test = await call('POST', '/warehouse/test');
     expect(test.status).toBe(200);
     expect(test.body.data).toMatchObject({ ok: true, tableCount: 1 });
-    expect(test.body.data).not.toHaveProperty('introspection');
 
     const tables = await call('GET', '/warehouse/remote-tables');
     expect(tables.status).toBe(200);

packages/services/service-datasource/src/external-datasource-service.ts

@@ -569,22 +569,19 @@ export class ExternalDatasourceService implements IExternalDatasourceService {
    *    name (ADR-0062), and it is not a federation source, so its tables are not
    *    introspected: that costs a round trip per table of the platform database
    *    and answers nothing the connection question needs. No `tableCount`.
-   *  - a driver with no `introspectSchema` (memory, mongodb). The answer says
-   *    so in `introspection: 'unsupported'`, rather than calling a connected
-   *    datasource failed.
+   *  - a driver with no `introspectSchema` (memory, mongodb). Its connected
+   *    datasource was called failed. It now answers the same health probe, and
+   *    the missing `tableCount` is the whole of what it cannot say.
    *
-   * Every other datasource is tested exactly as before. So is one with no live
-   * driver: `introspect` names the absence itself.
+   * Both answer `{ ok, latencyMs }`, the answer's existing keys: no key is added
+   * to say why `tableCount` is absent, because nothing reads one (the console's
+   * Test reads `ok`, `error` and `latencyMs`). Every other datasource is tested
+   * exactly as before. So is one with no live driver: `introspect` names the
+   * absence itself.
    */
   async testConnection(
     datasource: string,
-  ): Promise<{
-    ok: boolean;
-    latencyMs?: number;
-    tableCount?: number;
-    introspection?: 'unsupported';
-    error?: string;
-  }> {
+  ): Promise<{ ok: boolean; latencyMs?: number; tableCount?: number; error?: string }> {
     const started = Date.now();
     try {
       const driver = this.config.liveDriver?.(datasource);
@@ -593,11 +590,7 @@ export class ExternalDatasourceService implements IExternalDatasourceService {
         if (!(await driver.checkHealth())) {
           return { ok: false, error: `Datasource '${datasource}' is registered, but its driver failed its health check.` };
         }
-        return {
-          ok: true,
-          latencyMs: Date.now() - started,
-          ...(canIntrospect ? {} : { introspection: 'unsupported' as const }),
-        };
+        return { ok: true, latencyMs: Date.now() - started };
       }
       const schema = await this.config.introspect(datasource);
       return {