fix(service-analytics): every dataset answer names its base object

`queryDataset` set `object` only inside the two drill-through blocks, which
need a drillable dimension and at least one row. A dimension-less answer, a
zero-row answer, the draft-preview answer and the degraded "backing object
unavailable" answer went without it, although `AnalyticsResult.object`
declares it on every dataset answer.

`queryDataset` now wraps its former body (`answerDataset`) and sets
`object: dataset.object` once, on the path all three exits leave through,
as a copy rather than a write onto the answer. The two drill-block writes
and the local `AnalyticsResultWithDrill.object` member are retired; the
four drill sidecars are unchanged. `query()` does not pass through the
wrapper, so a cube answer carries no `object`.

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

Author: claude

.changeset/20644-dataset-answer-object.md

@@ -0,0 +1,22 @@
+---
+'@objectstack/service-analytics': patch
+---
+
+fix(service-analytics): every dataset answer names its base object as `object` (#20644)
+
+Clause-②: no
+
+**What was wrong.** `queryDataset` set `object`, the dataset's base object, only
+while it built drill-through metadata, which it builds only when a drillable
+dimension is selected and at least one row came back. A dimension-less (KPI)
+answer, a zero-row answer and the degraded answer for an unavailable backing
+object carried no `object`, and neither did a draft preview (`previewDrafts`),
+grouped or not. `POST /api/v1/analytics/dataset/query` relays the service answer
+as it is, so a consumer that refreshes on that object's record changes had
+nothing to subscribe to for those answers.
+
+**What changed.** Every `queryDataset` answer carries `object`, the dataset's
+`object` by machine name, whatever dimensions are selected and whether or not
+rows came back, as `AnalyticsResult.object` in `@objectstack/spec` declares. A
+grouped answer is unchanged: `object` sits beside the same drill-through keys
+as before. A cube `query` answer still carries no `object`.

packages/services/service-analytics/src/analytics-service.ts

@@ -92,10 +92,12 @@ import { ACCEPTED_SQL_DIALECTS, isUnrecognisedSqlDialectAnswer, type AcceptedSql
  * Analytics result augmented with drill-through metadata (ADR-0021 D2; see
  * queryDataset). Carried alongside `rows` so the host can drill a clicked bucket
  * back to the underlying records without the renderer knowing field mappings.
+ *
+ * The object those records belong to is not part of this augmentation: it is
+ * the contract's own `AnalyticsResult.object`, which every dataset answer
+ * carries, drillable or not (#20644).
  */
 type AnalyticsResultWithDrill = AnalyticsResult & {
-  /** The dataset's base object — the host drills into its records. */
-  object?: string;
   /** Selected drillable dimension NAME → underlying object FIELD name. */
   dimensionFields?: Record<string, string>;
   /**
@@ -1756,12 +1758,36 @@ export class AnalyticsService implements IAnalyticsService {
    * call's queries and nothing else, so a dataset named like a configured cube
    * neither replaces that cube nor re-publishes it, whatever the request's
    * admission answers.
+   *
+   * [#20644] Every answer names the dataset's base object as `object`
+   * (`AnalyticsResult.object`), whatever dimensions were selected and whether
+   * or not rows came back. It is set here, once, on the path every exit of
+   * {@link answerDataset} leaves through — the draft-preview return, the
+   * degraded "backing object unavailable" return and the main return — so an
+   * exit added later inherits it instead of needing its own copy. `query()`
+   * never passes through here, so a cube answer carries none.
    */
   async queryDataset(
     dataset: Dataset,
     selection: DatasetSelection,
     context?: ExecutionContext,
     options?: { previewDrafts?: boolean },
+  ): Promise<AnalyticsResult> {
+    const answer = await this.answerDataset(dataset, selection, context, options);
+    // A copy rather than a write onto `answer`, which may be the very object a
+    // strategy returned (the same ownership rule `applySqlEchoPolicy` keeps).
+    return { ...answer, object: dataset.object };
+  }
+
+  /**
+   * The body of {@link queryDataset}. None of its exits sets `object`: the
+   * caller sets it once, for all of them.
+   */
+  private async answerDataset(
+    dataset: Dataset,
+    selection: DatasetSelection,
+    context?: ExecutionContext,
+    options?: { previewDrafts?: boolean },
   ): Promise<AnalyticsResult> {
     const compiled = this.compile(dataset);
     this.logger.debug(`[Analytics] queryDataset "${dataset.name}" (object=${dataset.object}, include=${(dataset.include ?? []).join(',') || '—'})`);
@@ -1933,13 +1959,13 @@ export class AnalyticsService implements IAnalyticsService {
     // dimension NAMES, and the label resolution below OVERWRITES the raw grouped
     // value in each row with its display label. So before that happens, snapshot
     // the raw grouped values into a PARALLEL array (aligned to `rows` by index —
-    // the result rows are NOT mutated) and expose the dataset's `object` +
-    // dimension→field mapping so the renderer can build an exact-match filter.
+    // the result rows are NOT mutated) and expose the dimension→field mapping so
+    // the renderer can build an exact-match filter over the answer's `object`
+    // (set by {@link queryDataset} on every answer, drillable or not).
     // Date buckets are excluded — a humanized bucket ("2026-06") can't be
     // exact-matched against the stored timestamp, so they are not drillable.
     const drillDims = selectedDims.filter((d) => !!d.field && d.type !== 'date');
     if (drillDims.length && result.rows.length) {
-      (result as AnalyticsResultWithDrill).object = dataset.object;
       (result as AnalyticsResultWithDrill).dimensionFields = Object.fromEntries(
         drillDims.map((d) => [d.name, d.field as string]),
       );
@@ -2016,10 +2042,6 @@ export class AnalyticsService implements IAnalyticsService {
         }
         return ranges;
       });
-      // The equality drill block sets `object` only when a NON-date drill dim
-      // exists; a report grouped ONLY by time still needs the base object so the
-      // host can open its list. Safe to (re)set to the same dataset object.
-      (result as AnalyticsResultWithDrill).object = dataset.object;
     }
 
     // ADR-0021 — resolve grouped dimension values to human display labels