|
| 1 | +// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license. |
| 2 | + |
| 3 | +/** |
| 4 | + * #20644 — every dataset answer names its base object. |
| 5 | + * |
| 6 | + * `AnalyticsResult.object` (`@objectstack/spec/contracts`) is declared as a |
| 7 | + * producer obligation for `queryDataset`: EVERY dataset answer carries it, |
| 8 | + * whatever dimensions are selected and whether or not rows came back, and a |
| 9 | + * `query` (cube) answer carries none. A consumer keys its record-change |
| 10 | + * refresh on it, so a dimension-less KPI tile whose answer lacks it subscribes |
| 11 | + * to nothing and never re-reads. |
| 12 | + * |
| 13 | + * The service used to set it only inside the two drill-through blocks, which |
| 14 | + * need a drillable dimension AND at least one row. So a dimension-less answer, |
| 15 | + * a zero-row answer, the draft-preview answer (it returns before those blocks) |
| 16 | + * and the degraded "backing object unavailable" answer all went without. |
| 17 | + * |
| 18 | + * One block per exit `queryDataset` has — the main return, the draft-preview |
| 19 | + * return and the degraded return — and the contract's cube-side negative. The |
| 20 | + * main exit is driven through both strategies a dataset query can take, so the |
| 21 | + * answer does not depend on which one served it. |
| 22 | + */ |
| 23 | + |
| 24 | +import { describe, it, expect, vi } from 'vitest'; |
| 25 | +import { DatasetSchema } from '@objectstack/spec/ui'; |
| 26 | +import type { ExecutionContext } from '@objectstack/spec/kernel'; |
| 27 | +import type { AnalyticsResult } from '@objectstack/spec/contracts'; |
| 28 | +import { AnalyticsService } from '../analytics-service.js'; |
| 29 | + |
| 30 | +const CTX = { tenantId: 'org_A' } as ExecutionContext; |
| 31 | + |
| 32 | +const DATASET = DatasetSchema.parse({ |
| 33 | + name: 'pipeline', |
| 34 | + label: 'Pipeline', |
| 35 | + object: 'opportunity', |
| 36 | + include: [], |
| 37 | + dimensions: [{ name: 'stage', field: 'stage', type: 'string' }], |
| 38 | + measures: [{ name: 'revenue', aggregate: 'sum', field: 'amount' }], |
| 39 | +}); |
| 40 | + |
| 41 | +/** A KPI tile: no dimension selected. */ |
| 42 | +const KPI = { dimensions: [], measures: ['revenue'] }; |
| 43 | +/** A chart grouped by a drillable (non-date) dimension. */ |
| 44 | +const GROUPED = { dimensions: ['stage'], measures: ['revenue'] }; |
| 45 | + |
| 46 | +type Capabilities = () => { nativeSql: boolean; objectqlAggregate: boolean; inMemory: boolean }; |
| 47 | + |
| 48 | +const STRATEGY_PATHS: ReadonlyArray<{ label: string; capabilities: Capabilities }> = [ |
| 49 | + { label: 'NativeSQLStrategy', capabilities: () => ({ nativeSql: true, objectqlAggregate: false, inMemory: false }) }, |
| 50 | + { label: 'ObjectQLStrategy', capabilities: () => ({ nativeSql: false, objectqlAggregate: true, inMemory: false }) }, |
| 51 | +]; |
| 52 | + |
| 53 | +/** |
| 54 | + * A service whose driver answers `rows` to every query, on either strategy. |
| 55 | + * A dimension-less selection gets the rows with their dimension keys dropped, |
| 56 | + * which is what a real `GROUP BY`-less aggregate answers. |
| 57 | + */ |
| 58 | +function serviceAnswering(capabilities: Capabilities, rows: Record<string, unknown>[], extra: object = {}) { |
| 59 | + const answer = async () => rows.map((r) => ({ ...r })); |
| 60 | + return new AnalyticsService({ |
| 61 | + queryCapabilities: capabilities, |
| 62 | + executeRawSql: answer, |
| 63 | + executeAggregate: answer, |
| 64 | + ...extra, |
| 65 | + }); |
| 66 | +} |
| 67 | + |
| 68 | +describe.each(STRATEGY_PATHS)('the main exit names the base object — $label', ({ capabilities }) => { |
| 69 | + it('`dimensions: []` answers `object`', async () => { |
| 70 | + const answer = await serviceAnswering(capabilities, [{ revenue: 150 }]).queryDataset(DATASET, KPI, CTX); |
| 71 | + |
| 72 | + expect(answer.rows).toEqual([{ revenue: 150 }]); |
| 73 | + expect(answer.object).toBe('opportunity'); |
| 74 | + }); |
| 75 | + |
| 76 | + it('a zero-row answer answers `object` — grouped or not', async () => { |
| 77 | + const svc = serviceAnswering(capabilities, []); |
| 78 | + |
| 79 | + const grouped = await svc.queryDataset(DATASET, GROUPED, CTX); |
| 80 | + expect(grouped.rows).toEqual([]); |
| 81 | + expect(grouped.object).toBe('opportunity'); |
| 82 | + |
| 83 | + const kpi = await svc.queryDataset(DATASET, KPI, CTX); |
| 84 | + expect(kpi.rows).toEqual([]); |
| 85 | + expect(kpi.object).toBe('opportunity'); |
| 86 | + }); |
| 87 | + |
| 88 | + it('a grouped answer is unchanged: `object` beside the drill-through keys it always carried', async () => { |
| 89 | + const answer = await serviceAnswering(capabilities, [{ stage: 'won', revenue: 100 }]).queryDataset( |
| 90 | + DATASET, |
| 91 | + GROUPED, |
| 92 | + CTX, |
| 93 | + ); |
| 94 | + |
| 95 | + expect(answer).toMatchObject({ |
| 96 | + rows: [{ stage: 'won', revenue: 100 }], |
| 97 | + object: 'opportunity', |
| 98 | + dimensionFields: { stage: 'stage' }, |
| 99 | + drillRawRows: [{ stage: 'won' }], |
| 100 | + }); |
| 101 | + }); |
| 102 | +}); |
| 103 | + |
| 104 | +describe('the draft-preview exit names the base object', () => { |
| 105 | + // The preview branch evaluates the selection over the base object's pending |
| 106 | + // seed rows in memory and returns early, ahead of everything the main exit |
| 107 | + // does after the query — so it is the exit a drill-branch-only `object` never |
| 108 | + // reached, grouped or not. |
| 109 | + const SEED = [ |
| 110 | + { stage: 'won', amount: 100 }, |
| 111 | + { stage: 'lost', amount: 50 }, |
| 112 | + ]; |
| 113 | + const previewService = () => |
| 114 | + serviceAnswering(STRATEGY_PATHS[1].capabilities, [], { draftRowsResolver: async () => SEED }); |
| 115 | + |
| 116 | + it('a dimension-less preview answers `object`', async () => { |
| 117 | + const answer = await previewService().queryDataset(DATASET, KPI, CTX, { previewDrafts: true }); |
| 118 | + |
| 119 | + expect(answer.rows).toEqual([{ revenue: 150 }]); |
| 120 | + expect(answer.object).toBe('opportunity'); |
| 121 | + }); |
| 122 | + |
| 123 | + it('a grouped preview answers `object`', async () => { |
| 124 | + const answer = await previewService().queryDataset(DATASET, GROUPED, CTX, { previewDrafts: true }); |
| 125 | + |
| 126 | + expect(answer.rows).toHaveLength(2); |
| 127 | + expect(answer.object).toBe('opportunity'); |
| 128 | + }); |
| 129 | +}); |
| 130 | + |
| 131 | +describe('the degraded exit names the base object', () => { |
| 132 | + it('"backing object unavailable" answers no rows, and still `object`', async () => { |
| 133 | + const logger = { info: vi.fn(), debug: vi.fn(), warn: vi.fn(), error: vi.fn(), child: vi.fn() } as any; |
| 134 | + const svc = new AnalyticsService({ |
| 135 | + queryCapabilities: STRATEGY_PATHS[0].capabilities, |
| 136 | + executeRawSql: async () => { |
| 137 | + throw new Error('SELECT SUM("amount") FROM "opportunity" - no such table: opportunity'); |
| 138 | + }, |
| 139 | + logger, |
| 140 | + }); |
| 141 | + |
| 142 | + const answer = await svc.queryDataset(DATASET, KPI, CTX); |
| 143 | + |
| 144 | + expect(answer).toEqual({ rows: [], fields: [], totals: [], object: 'opportunity' }); |
| 145 | + // …and it is the degraded exit that answered, not a main-exit zero-row one. |
| 146 | + expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('backing object "opportunity" is unavailable')); |
| 147 | + }); |
| 148 | +}); |
| 149 | + |
| 150 | +describe.each(STRATEGY_PATHS)('a cube `query` answer carries no `object` — $label', ({ capabilities }) => { |
| 151 | + // The negative the contract states: a cube answer has no dataset behind it. |
| 152 | + // The hardest case for it is a cube that IS a registered dataset's compiled |
| 153 | + // cube, queried by name through `query()` on a service that has just answered |
| 154 | + // a dataset query for the same dataset — every query `queryDataset` issues |
| 155 | + // runs through the same body as `query()`, so an `object` stamped anywhere |
| 156 | + // on that shared path would surface here. |
| 157 | + it('not on a registered dataset\'s cube, not after a dataset answer on the same service', async () => { |
| 158 | + const svc = serviceAnswering(capabilities, [{ revenue: 150 }], { datasets: [DATASET] }); |
| 159 | + |
| 160 | + // A dataset answer first, from the same service over the same compiled cube. |
| 161 | + await svc.queryDataset(DATASET, KPI, CTX); |
| 162 | + |
| 163 | + const cube: AnalyticsResult = await svc.query({ cube: 'pipeline', measures: ['revenue'] }, CTX); |
| 164 | + expect(cube.rows).toEqual([{ revenue: 150 }]); |
| 165 | + expect('object' in cube).toBe(false); |
| 166 | + }); |
| 167 | +}); |
0 commit comments