measurr 0.7.0 → 0.8.0

package/dist/handler.d.ts

@@ -3,7 +3,7 @@
  * as each finishes), and engine errors as HTTP errors. Framework-neutral; an oRPC or tRPC
  * procedure wraps these in a few lines.
  */
-import { type Analytics, AnalyticsError, type AnalyticsErrorCode, type AnalyticsErrorDetails } from './analytics.js';
+import { type Analytics, AnalyticsError, type AnalyticsErrorCode, type AnalyticsErrorDetails, type QueryOptions } from './analytics.js';
 import type { AnyDataset } from './dataset.js';
 import type { DatasetQuery, ResultOf } from './query.js';
 /** Why one query of a batch failed. Errors other than `AnalyticsError` are not described. */
@@ -33,9 +33,14 @@ type Queries<DS extends readonly AnyDataset[]> = Record<string, DatasetQuery<DS[
  * Runs named queries in parallel. One query failing does not fail the others: its error is
  * under its name. Each query is authorized, cached and reported like a single `query`.
  */
-export declare function queryBatch<DS extends readonly AnyDataset[], Ctx, const Q extends Queries<DS>>(analytics: Analytics<DS, Ctx>, queries: Q, ctx: Ctx): Promise<BatchResult<DS, Q>>;
-/** Runs named queries in parallel and yields each as it finishes, for a streaming endpoint. */
-export declare function streamBatch<DS extends readonly AnyDataset[], Ctx, const Q extends Queries<DS>>(analytics: Analytics<DS, Ctx>, queries: Q, ctx: Ctx): AsyncGenerator<BatchChunk<DS, Q>, void, undefined>;
+export declare function queryBatch<DS extends readonly AnyDataset[], Ctx, const Q extends Queries<DS>>(analytics: Analytics<DS, Ctx>, queries: Q, ctx: Ctx, options?: BatchOptions): Promise<BatchResult<DS, Q>>;
+/** Aborting `signal` stops the batch's statements and rejects with its reason. */
+export type BatchOptions = Pick<QueryOptions, 'signal'>;
+/**
+ * Runs named queries in parallel and yields each as it finishes, for a streaming endpoint. A
+ * consumer that stops reading (a closed stream) stops the statements still running.
+ */
+export declare function streamBatch<DS extends readonly AnyDataset[], Ctx, const Q extends Queries<DS>>(analytics: Analytics<DS, Ctx>, queries: Q, ctx: Ctx, options?: BatchOptions): AsyncGenerator<BatchChunk<DS, Q>, void, undefined>;
 export type HttpError = {
     status: 400 | 401 | 403;
     /** The status name oRPC and tRPC use for it. */

package/dist/handler.js

@@ -1,11 +1,57 @@
 import {
-  queryBatch2,
-  streamBatch2,
-  toHttpError2
-} from "./index-psw9s799.js";
-import"./index-g0ah4ehn.js";
+  AnalyticsError2
+} from "./index-8nhqje4s.js";
+
+// src/handler.ts
+async function queryBatch(analytics, queries, ctx, options) {
+  const results = {};
+  const errors = {};
+  for await (const chunk of streamBatch(analytics, queries, ctx, options)) {
+    if ("error" in chunk)
+      errors[chunk.key] = chunk.error;
+    else
+      results[chunk.key] = chunk.result;
+  }
+  return { results, errors };
+}
+async function* streamBatch(analytics, queries, ctx, options = {}) {
+  options.signal?.throwIfAborted();
+  const controller = new AbortController;
+  const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
+  try {
+    const pending = new Map(Object.entries(queries).map(([key, query]) => {
+      const settled = analytics.query(query, ctx, { signal }).then((result) => ({ key, result }), (error) => ({ key, error: batchError(error) }));
+      return [key, settled];
+    }));
+    while (pending.size > 0) {
+      const chunk = await Promise.race(pending.values());
+      signal.throwIfAborted();
+      pending.delete(chunk.key);
+      yield chunk;
+    }
+  } finally {
+    controller.abort();
+  }
+}
+function batchError(error) {
+  return error instanceof AnalyticsError2 ? { code: error.code, message: error.message } : { code: "internal", message: "The query failed" };
+}
+function toHttpError(error) {
+  if (error.code === "forbidden") {
+    return { status: 403, code: "FORBIDDEN", message: error.message };
+  }
+  if (error.code === "missing_tenant") {
+    return { status: 401, code: "UNAUTHORIZED", message: error.message };
+  }
+  return {
+    status: 400,
+    code: "BAD_REQUEST",
+    message: error.message,
+    data: { code: error.code, details: error.details }
+  };
+}
 export {
-  queryBatch2 as queryBatch,
-  streamBatch2 as streamBatch,
-  toHttpError2 as toHttpError
+  queryBatch,
+  streamBatch,
+  toHttpError
 };

package/dist/{index-g0ah4ehn.js → index-8nhqje4s.js}

@@ -98,7 +98,8 @@ function filterSchema(key, dim) {
       ]).describe(`${description} (bucket start dates, inclusive)`);
   }
 }
-function datasetQuerySchema(dataset) {
+function datasetQuerySchema(dataset, options = {}) {
+  const maxLimit = options.maxLimit ?? MAX_LIMIT;
   const measures = Object.entries(dataset.measures);
   const dimensions = Object.entries(dataset.dimensions);
   const groupable = dimensions.filter(([, dim]) => dim.groupable);
@@ -131,7 +132,8 @@ function datasetQuerySchema(dataset) {
       by: z.enum(sortKeys),
       direction: z.enum(["asc", "desc"]).optional()
     }).optional().describe("One of the asked measures or grouped dimensions. Defaults to time order when grouped by time, otherwise the first measure, descending."),
-    limit: z.number().int().min(1).max(MAX_LIMIT).optional().describe(`Maximum number of groups. Defaults to ${DEFAULT_LIMIT}.`)
+    limit: z.number().int().min(1).max(maxLimit).optional().describe(`Maximum number of groups. Defaults to ${DEFAULT_LIMIT}.`),
+    ...options.parse && { totals: z.boolean().optional() }
   }).superRefine((query, context) => {
     const { groupBy } = query;
     const by = query.sort?.by;
@@ -161,8 +163,8 @@ function datasetQuerySchema(dataset) {
     }
   });
 }
-function buildQuerySchema(datasets) {
-  const [first, ...rest] = datasets.map(datasetQuerySchema);
+function buildQuerySchema(datasets, options = {}) {
+  const [first, ...rest] = datasets.map((dataset) => datasetQuerySchema(dataset, options));
   if (!first)
     throw new Error("querySchema needs at least one dataset");
   return z.discriminatedUnion("dataset", [first, ...rest]);
@@ -181,14 +183,41 @@ var dimensionValue = z.object({
   key: z.union([z.string(), z.number()]).nullable(),
   label: z.string()
 });
+var fieldsOutput = z.object({
+  groupBy: z.array(z.object({
+    key: z.string(),
+    label: z.string(),
+    kind: z.enum([
+      "enum",
+      "computed",
+      "relation",
+      "manyToMany",
+      "number",
+      "timePart",
+      "timeBucket"
+    ]),
+    unit: z.enum(["day", "week", "month"]).optional(),
+    values: z.array(z.object({ key: z.string(), label: z.string() })).optional()
+  })),
+  measures: z.array(z.object({
+    key: z.string(),
+    label: z.string(),
+    valueType: z.enum(["count", "number", "ratio"])
+  }))
+});
 function resultSchemaOf(row, totals) {
   return z.object({
     period: periodOutput,
     rows: z.array(row),
-    totals,
-    previous: z.object({ period: rangeOutput, rows: z.array(row), totals }).optional(),
+    totals: totals.optional(),
+    previous: z.object({
+      period: rangeOutput,
+      rows: z.array(row),
+      totals: totals.optional()
+    }).optional(),
     notes: z.array(z.string()),
-    truncated: z.boolean()
+    truncated: z.boolean(),
+    fields: fieldsOutput.optional()
   });
 }
 function datasetResultSchema(dataset) {
@@ -216,7 +245,8 @@ function normalizeQuery(dataset, parsed) {
     time: parsed.time ?? dataset.defaultTime,
     compareToPrevious: parsed.compareToPrevious ?? false,
     sort: parsed.sort ? { by: parsed.sort.by, direction: parsed.sort.direction ?? "desc" } : null,
-    limit: parsed.limit ?? DEFAULT_LIMIT
+    limit: parsed.limit ?? DEFAULT_LIMIT,
+    totals: parsed.totals ?? true
   };
 }
 var allTenants2 = Symbol("measurr.allTenants");
@@ -320,25 +350,20 @@ function dimensionNodes(dataset, key, timezone) {
     }
   }
 }
+function tenantWhere(column, tenant) {
+  const ids = typeof tenant === "object" ? [...new Set(tenant)] : [tenant];
+  const [only] = ids;
+  return [
+    ids.length === 1 && only !== undefined ? { kind: "compare", op: "=", left: column, right: param(only) } : { kind: "in", item: column, values: ids.map(param), negated: false }
+  ];
+}
 function baseWhere(dataset, tenant, period) {
   const where = [];
   if (tenant !== allTenants2) {
     if (!dataset.tenantColumn) {
       throw new Error(`Dataset ${dataset.key} has no tenant column; only allTenants may query it`);
     }
-    const ids = typeof tenant === "object" ? [...new Set(tenant)] : [tenant];
-    const [only] = ids;
-    where.push(ids.length === 1 && only !== undefined ? {
-      kind: "compare",
-      op: "=",
-      left: dataset.tenantColumn,
-      right: param(only)
-    } : {
-      kind: "in",
-      item: dataset.tenantColumn,
-      values: ids.map(param),
-      negated: false
-    });
+    where.push(...tenantWhere(dataset.tenantColumn, tenant));
   }
   if (dataset.scope)
     where.push(dataset.scope);
@@ -403,7 +428,7 @@ function filterNode(dataset, filter, context) {
         values: values.map(param),
         negated: filter.op === "notIn"
       };
-      if (filter.op === "in")
+      if (filter.op === "in" || neverNull(key))
         return list;
       return {
         kind: "logical",
@@ -413,6 +438,13 @@ function filterNode(dataset, filter, context) {
     }
   }
 }
+function neverNull(node) {
+  if (node.kind === "param")
+    return node.value !== null;
+  if (node.kind !== "case" || !node.otherwise)
+    return false;
+  return neverNull(node.otherwise) && node.branches.every((branch) => neverNull(branch.result));
+}
 var columnAlias = {
   measure: (key) => `m_${key}`,
   groupKey: (key) => `g_${key}`,
@@ -488,9 +520,11 @@ function orderBy(dataset, query, select) {
   return order;
 }
 function planLookup(dataset, dimensionKey, tenant, values, now) {
+  const dimension = dimensionOf(dataset, dimensionKey);
+  const lookup = dimension.kind === "relation" || dimension.kind === "manyToMany" ? dimension.lookup : undefined;
   const nodes = dimensionNodes(dataset, dimensionKey, "UTC");
   const label = nodes.label ?? nodes.key;
-  const where = baseWhere(dataset, tenant, null);
+  const where = lookup ? lookupWhere(dataset, lookup.tenantColumn, tenant) : baseWhere(dataset, tenant, null);
   where.push({ kind: "isNull", item: nodes.key, negated: true });
   if (values) {
     where.push({
@@ -513,8 +547,8 @@ function planLookup(dataset, dimensionKey, tenant, values, now) {
     });
   }
   return {
-    from: dataset.from,
-    virtualJoins: nodes.virtualJoin ? [nodes.virtualJoin] : [],
+    from: lookup ? lookup.table : dataset.from,
+    virtualJoins: !lookup && nodes.virtualJoin ? [nodes.virtualJoin] : [],
     where,
     select: [
       { alias: "key", node: nodes.key },
@@ -526,6 +560,15 @@ function planLookup(dataset, dimensionKey, tenant, values, now) {
     now
   };
 }
+function lookupWhere(dataset, tenantColumn, tenant) {
+  if (tenant === allTenants2 || !tenantColumn) {
+    if (!dataset.tenantColumn && tenant !== allTenants2) {
+      throw new Error(`Dataset ${dataset.key} has no tenant column; only allTenants may query it`);
+    }
+    return [];
+  }
+  return tenantWhere(tenantColumn, tenant);
+}
 var WEEKDAYS = [
   "Monday",
   "Tuesday",
@@ -637,13 +680,17 @@ function createAnalytics2(options) {
   const byKey = new Map;
   const sourceOf = new Map;
   const restrictedOf = new Map;
+  const fingerprints = new Map;
   for (const dataset of datasets) {
     if (byKey.has(dataset.key))
       throw new Error(`Two datasets use the key ${dataset.key}`);
     byKey.set(dataset.key, dataset);
     const source = resolveSource(dataset, options.sources, sourceNames);
     sourceOf.set(dataset.key, source);
-    compileEverything(dataset, source.dialect);
+    const compiled = compileEverything(dataset, source.dialect);
+    if (options.cache) {
+      fingerprints.set(dataset.key, sha256(compiled + stableJson(catalogEntry(dataset))));
+    }
     const restricted = restrictedFields(dataset);
     if (restricted.length > 0 && !options.authorizeField) {
       throw new Error(`Dataset ${dataset.key} marks fields with access, but createAnalytics has no authorizeField`);
@@ -672,6 +719,26 @@ function createAnalytics2(options) {
   const now = options.now ?? (() => new Date);
   const querySchemas = new Map;
   const resultSchemas = new Map;
+  const parseSchema = buildQuerySchema(datasets, {
+    parse: true,
+    maxLimit: options.maxLimit
+  });
+  const limiters = new Map;
+  if (options.concurrency !== undefined) {
+    for (const source of new Set(Object.values(options.sources)))
+      limiters.set(source, semaphore(options.concurrency));
+  }
+  const inFlight = new Map;
+  const execute = async (source, statement, signal) => {
+    signal?.throwIfAborted();
+    const release = await limiters.get(source)?.(signal);
+    try {
+      signal?.throwIfAborted();
+      return await (signal ? source.execute(statement, { signal }) : source.execute(statement));
+    } finally {
+      release?.();
+    }
+  };
   const datasetOf = (key) => {
     const dataset = byKey.get(key);
     if (!dataset)
@@ -741,6 +808,32 @@ function createAnalytics2(options) {
     }
     return querySchemaFor(allowed);
   };
+  const scopeOf = (ctx) => {
+    const tenant = options.tenant(ctx);
+    if (!isTenant(tenant)) {
+      throw new AnalyticsError2("missing_tenant", "Refusing to query without a tenant");
+    }
+    return tenant;
+  };
+  const resolveIn = (input, timezone, at) => {
+    if ("all" in input)
+      return null;
+    try {
+      return resolvePeriod(input, timezone, at);
+    } catch (error) {
+      if (error instanceof PeriodError) {
+        throw new AnalyticsError2("invalid_period", error.message);
+      }
+      throw error;
+    }
+  };
+  const periodOf = async (input, ctx) => {
+    const parsed = periodSchema.safeParse(input);
+    if (!parsed.success) {
+      throw new AnalyticsError2("invalid_period", `Invalid period: ${z2.prettifyError(parsed.error)}`);
+    }
+    return resolveIn(parsed.data, await timezoneOf(ctx), now());
+  };
   const timezoneOf = async (ctx) => {
     const timezone = await options.timezone?.(ctx) || "UTC";
     if (!isValidTimezone(timezone)) {
@@ -749,7 +842,7 @@ function createAnalytics2(options) {
     return timezone;
   };
   const prepare = async (input, ctx) => {
-    const parsed = querySchemaFor(datasets).safeParse(input);
+    const parsed = parseSchema.safeParse(input);
     if (!parsed.success) {
       throw new AnalyticsError2("invalid_query", `Invalid analytics query: ${z2.prettifyError(parsed.error)}`, parsed.error.issues);
     }
@@ -767,33 +860,22 @@ function createAnalytics2(options) {
       const names = refused.map((field) => `${field.kind} ${field.key}`);
       throw new AnalyticsError2("forbidden", `Not allowed to use ${names.join(", ")} of ${dataset.key}`);
     }
-    const tenant = options.tenant(ctx);
-    if (!isTenant(tenant)) {
-      throw new AnalyticsError2("missing_tenant", "Refusing to query without a tenant");
-    }
+    const tenant = scopeOf(ctx);
     if (!dataset.tenantColumn && tenant !== allTenants2) {
       throw new AnalyticsError2("forbidden", `${dataset.key} has no tenant column; only a caller allowed to see every tenant may query it`);
     }
     const timezone = await timezoneOf(ctx);
     const query = normalizeQuery(dataset, parsedQuery);
     const at = now();
-    let period;
-    try {
-      period = "all" in query.period ? null : resolvePeriod(query.period, timezone, at);
-    } catch (error) {
-      if (error instanceof PeriodError) {
-        throw new AnalyticsError2("invalid_period", error.message);
-      }
-      throw error;
-    }
+    const period = resolveIn(query.period, timezone, at);
     const previous = query.compareToPrevious && period ? previousPeriod(period) : null;
     return { dataset, query, tenant, timezone, period, previous, now: at };
   };
-  const runQuery = async (prepared, ctx) => {
+  const runQuery = async (prepared, ctx, signal) => {
     const { dataset, query, tenant, timezone, period, previous, now } = prepared;
     const source = sourceFor(dataset);
     const { dialect } = source;
-    const run = (statement) => source.execute(dialect.compile(statement));
+    const run = (statement) => execute(source, dialect.compile(statement), signal);
     const resolvedValues = await resolveOpenValues(dataset, query, tenant, now, run, dialect);
     const range = ({ from, to }) => ({ from, to, timezone });
     const runPeriod = async (target) => {
@@ -809,7 +891,8 @@ function createAnalytics2(options) {
         statements.totals ? run(statements.totals) : null
       ]);
       const { rows, kept, truncated } = shapeRows(dataset, query, rawRows, dialect);
-      const totalsRow = (rawTotals ?? rawRows)[0] ?? {};
+      const grouped = query.groupBy.length > 0;
+      const totalsRow = (rawTotals ?? (grouped ? [] : rawRows))[0] ?? {};
       const totals = shapeMeasures(dataset, query.measures, totalsRow, dialect);
       for (const key of query.measures) {
         const entry = dataset.measures[key];
@@ -846,20 +929,20 @@ function createAnalytics2(options) {
         });
         totals[key] = value(output.totals);
       }
-      return { rows, totals, truncated };
+      return { rows, ...query.totals && { totals }, truncated };
     };
     const [current, before] = await Promise.all([
       runPeriod(period),
       previous && runPeriod(previous).then(({ rows, totals }) => ({
         period: range(previous),
         rows,
-        totals
+        ...totals && { totals }
       }))
     ]);
     return {
       period: period ? range(period) : { all: true, timezone },
       rows: current.rows,
-      totals: current.totals,
+      ...current.totals && { totals: current.totals },
       ...before && { previous: before },
       notes: resultNotes(dataset, query),
       truncated: current.truncated
@@ -892,34 +975,48 @@ function createAnalytics2(options) {
       Promise.resolve(options.cache?.set(key, result, entry)).catch(() => {});
     } catch {}
   };
-  const query = async (input, ctx) => {
+  const query = async (input, ctx, queryOptions = {}) => {
+    const { signal, metric } = queryOptions;
     const startedAt = performance.now();
     const dataset = datasetKeyOf(input);
     const durationMs = () => Math.round(performance.now() - startedAt);
     let cache;
     try {
+      signal?.throwIfAborted();
       const prepared = await prepare(input, ctx);
-      const entry = { dataset: prepared.dataset.key, ctx };
-      const key = options.cache && await cacheKey(prepared);
+      const entry = {
+        dataset: prepared.dataset.key,
+        ctx,
+        ...metric !== undefined && { metric }
+      };
+      const fingerprint = fingerprints.get(prepared.dataset.key);
+      const key = options.cache && fingerprint ? await cacheKey(prepared, await fingerprint) : null;
       let result = key ? await cachedResult(key, entry) : null;
       if (key)
         cache = result ? "hit" : "miss";
       if (!result) {
-        result = await runQuery(prepared, ctx);
-        if (key)
-          store(key, result, entry);
+        result = key ? await share(inFlight, key, async (shared) => {
+          const fresh = await runQuery(prepared, ctx, shared);
+          store(key, fresh, entry);
+          return fresh;
+        }, signal) : await runQuery(prepared, ctx, signal);
       }
       report({
         dataset,
+        ...metric !== undefined && { metric },
         durationMs: durationMs(),
         rows: result.rows.length,
         outcome: "success",
         ...cache && { cache }
       }, ctx);
-      return result;
+      return {
+        ...result,
+        fields: resultFields(prepared.dataset, prepared.query)
+      };
     } catch (error) {
       report({
         dataset,
+        ...metric !== undefined && { metric },
         durationMs: durationMs(),
         rows: 0,
         outcome: "error",
@@ -954,23 +1051,94 @@ function createAnalytics2(options) {
     querySchema: (schemaOptions) => schemaOptions && ("ctx" in schemaOptions) ? querySchemaForCtx(schemaOptions.ctx) : querySchemaFor(schemaOptions?.datasets?.map(datasetOf) ?? datasets),
     resultSchema: (key) => resultSchemaFor(key),
     timezone: timezoneOf,
+    period: periodOf,
+    scope: scopeOf,
     listDatasets: async (ctx) => (await allowedDatasets(ctx)).map((dataset) => catalogEntry(dataset))
   };
 }
-async function cacheKey(prepared) {
+async function cacheKey(prepared, fingerprint) {
   const { dataset, query, tenant, timezone, period, previous } = prepared;
   const days = (target) => target && [target.from, target.to];
   const scope = tenant === allTenants2 ? { all: true } : Array.isArray(tenant) ? [...new Set(tenant.map((id) => JSON.stringify(id)))].sort() : tenant;
   const text = stableJson({
+    definition: fingerprint,
     query,
     tenant: scope,
     timezone,
     period: days(period),
     previous: days(previous)
   });
+  return `measurr:${dataset.key}:${await sha256(text)}`;
+}
+async function sha256(text) {
   const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
-  const hex = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
-  return `measurr:${dataset.key}:${hex}`;
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function semaphore(max) {
+  if (!Number.isInteger(max) || max < 1)
+    throw new Error(`concurrency must be a whole number of at least 1, not ${max}`);
+  let active = 0;
+  const queue = [];
+  const release = () => {
+    const next = queue.shift();
+    if (next)
+      next();
+    else
+      active--;
+  };
+  return async (signal) => {
+    if (active < max) {
+      active++;
+      return release;
+    }
+    await new Promise((resolve, reject) => {
+      const onAbort = () => {
+        queue.splice(queue.indexOf(wake), 1);
+        reject(signal?.reason);
+      };
+      const wake = () => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      };
+      queue.push(wake);
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+    return release;
+  };
+}
+function share(inFlight, key, start, signal) {
+  let entry = inFlight.get(key);
+  if (!entry) {
+    const controller = new AbortController;
+    const created = {
+      controller,
+      waiting: 0,
+      promise: start(controller.signal).finally(() => {
+        if (inFlight.get(key) === created)
+          inFlight.delete(key);
+      })
+    };
+    inFlight.set(key, created);
+    entry = created;
+  }
+  const shared = entry;
+  shared.waiting++;
+  if (!signal)
+    return shared.promise;
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      if (--shared.waiting === 0) {
+        if (inFlight.get(key) === shared)
+          inFlight.delete(key);
+        shared.controller.abort(signal.reason);
+      }
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    shared.promise.then(resolve, reject).finally(() => {
+      signal.removeEventListener("abort", onAbort);
+    });
+  });
 }
 function stableJson(value) {
   return JSON.stringify(value, (_key, inner) => inner && typeof inner === "object" && !Array.isArray(inner) ? Object.fromEntries(Object.entries(inner).sort(([a], [b]) => a < b ? -1 : 1)) : inner);
@@ -983,9 +1151,10 @@ function isTenantId(value) {
 }
 function periodStatements(dataset, query, context) {
   const grouped = query.groupBy.length > 0;
+  const resolved = query.measures.some((key) => dataset.measures[key]?.kind === "resolved");
   return {
     rows: planQuery(dataset, query, context, true),
-    totals: grouped ? planQuery(dataset, query, context, false) : null
+    totals: grouped && (query.totals || resolved) ? planQuery(dataset, query, context, false) : null
   };
 }
 function resolveSource(dataset, sources, sourceNames) {
@@ -1009,11 +1178,15 @@ function compileEverything(dataset, dialect) {
   };
   const measures = Object.keys(dataset.measures);
   const base = normalizeQuery(dataset, { dataset: dataset.key, measures });
+  const texts = [];
+  const compile = (statement) => {
+    texts.push(dialect.compile(statement).text);
+  };
   try {
-    dialect.compile(planQuery(dataset, base, context, true));
+    compile(planQuery(dataset, base, context, true));
     for (const [key, dimension] of Object.entries(dataset.dimensions)) {
       if (dimension.groupable) {
-        dialect.compile(planQuery(dataset, { ...base, groupBy: [key] }, context, true));
+        compile(planQuery(dataset, { ...base, groupBy: [key] }, context, true));
       }
       if (dimension.filterable) {
         const filter = dimension.category === "numeric" ? { dimension: key, op: "between", from: 0, to: 1 } : dimension.category === "time" ? {
@@ -1022,13 +1195,15 @@ function compileEverything(dataset, dialect) {
           from: "2000-01-01",
           to: "2000-01-02"
         } : { dimension: key, op: "in", values: ["value"] };
-        dialect.compile(planQuery(dataset, { ...base, filters: [filter] }, context, true));
+        compile(planQuery(dataset, { ...base, filters: [filter] }, context, true));
       }
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Dataset ${dataset.key} does not compile for ${dialect.name}: ${message}`);
   }
+  return texts.join(`
+`);
 }
 async function resolveOpenValues(dataset, query, tenant, now, run, dialect) {
   const resolved = new Map;
@@ -1123,7 +1298,7 @@ function catalogEntry(dataset) {
       key,
       label: entry.label,
       description: entry.description,
-      valueType: entry.kind !== "aggregate" ? "ratio" : entry.node.fn === "count" || entry.node.fn === "countDistinct" ? "count" : "number"
+      valueType: entry.result
     })),
     dimensions: Object.entries(dataset.dimensions).map(([key, entry]) => ({
       key,
@@ -1133,12 +1308,31 @@ function catalogEntry(dataset) {
       category: entry.category,
       groupable: entry.groupable,
       filterable: entry.filterable,
-      values: entry.kind === "enum" || entry.kind === "computed" ? Object.entries(entry.values).map(([value, label]) => ({
-        key: value,
-        label
-      })) : undefined
+      values: closedValues(entry)
     }))
   };
 }
+function closedValues(dimension) {
+  return dimension.kind === "enum" || dimension.kind === "computed" ? Object.entries(dimension.values).map(([key, label]) => ({ key, label })) : undefined;
+}
+function resultFields(dataset, query) {
+  return {
+    groupBy: query.groupBy.map((key) => {
+      const dimension = dataset.dimensions[key];
+      const values = closedValues(dimension);
+      return {
+        key,
+        label: dimension.label,
+        kind: dimension.kind,
+        ...dimension.kind === "timeBucket" && { unit: dimension.unit },
+        ...values && { values }
+      };
+    }),
+    measures: query.measures.map((key) => {
+      const entry = dataset.measures[key];
+      return { key, label: entry.label, valueType: entry.result };
+    })
+  };
+}
 
-export { MAX_MEASURES, AnalyticsResultSchema2, allTenants2, AnalyticsError2, isAnalyticsError2, createAnalytics2 };
+export { MAX_MEASURES, periodSchema, periodOutput, AnalyticsResultSchema2, allTenants2, AnalyticsError2, isAnalyticsError2, createAnalytics2 };