measurr 0.1.0

package/dist/index-m0czpsyv.js

@@ -0,0 +1,1292 @@
+import {
+  rootOf,
+  directChildren
+} from "./index-e6k30sfp.js";
+
+// src/query.ts
+import { z } from "zod";
+
+// src/period.ts
+var MAX_PERIOD_DAYS = 731;
+var DEFAULT_PERIOD = { last: { days: 30 } };
+var DAY_MS = 86400000;
+var formatterCache = new Map;
+function formatter(timezone) {
+  let cached = formatterCache.get(timezone);
+  if (!cached) {
+    cached = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      hourCycle: "h23",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    });
+    formatterCache.set(timezone, cached);
+  }
+  return cached;
+}
+function isValidTimezone(timezone) {
+  if (!/^[A-Za-z][A-Za-z0-9_+\-/]*$/.test(timezone))
+    return false;
+  try {
+    formatter(timezone);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function localParts(instant, timezone) {
+  const parts = {};
+  for (const part of formatter(timezone).formatToParts(instant)) {
+    if (part.type !== "literal")
+      parts[part.type] = Number(part.value);
+  }
+  return {
+    year: parts.year ?? 0,
+    month: parts.month ?? 1,
+    day: parts.day ?? 1,
+    hour: parts.hour ?? 0,
+    minute: parts.minute ?? 0,
+    second: parts.second ?? 0
+  };
+}
+function offsetAt(instant, timezone) {
+  const p = localParts(instant, timezone);
+  const asUtc = Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second);
+  return asUtc - (instant.getTime() - instant.getUTCMilliseconds());
+}
+function localDate(instant, timezone) {
+  const p = localParts(instant, timezone);
+  return formatDate(Date.UTC(p.year, p.month - 1, p.day));
+}
+function startOfLocalDay(date, timezone) {
+  const wallClock = parseDate(date);
+  const firstGuess = wallClock - offsetAt(new Date(wallClock), timezone);
+  const corrected = wallClock - offsetAt(new Date(firstGuess), timezone);
+  return new Date(corrected);
+}
+function parseDate(date) {
+  const [year, month, day] = date.split("-").map(Number);
+  return Date.UTC(year ?? 0, (month ?? 1) - 1, day ?? 1);
+}
+function formatDate(utcMs) {
+  return new Date(utcMs).toISOString().slice(0, 10);
+}
+function addDays(date, days) {
+  return formatDate(parseDate(date) + days * DAY_MS);
+}
+function daysBetween(from, to) {
+  return Math.round((parseDate(to) - parseDate(from)) / DAY_MS);
+}
+function isoWeekday(date) {
+  const day = new Date(parseDate(date)).getUTCDay();
+  return day === 0 ? 7 : day;
+}
+
+class PeriodError extends Error {
+  name = "PeriodError";
+}
+function resolvePeriod(input, timezone, now) {
+  const today = localDate(now, timezone);
+  const [from, to] = periodDays(input, today);
+  if (daysBetween(from, to) < 0) {
+    throw new PeriodError(`The period starts (${from}) after it ends (${to}).`);
+  }
+  return periodFromDays(from, to, timezone);
+}
+function periodDays(input, today) {
+  if ("last" in input)
+    return [addDays(today, -(input.last.days - 1)), today];
+  if ("from" in input)
+    return [input.from, input.to];
+  const monthStart = `${today.slice(0, 8)}01`;
+  const weekStart = addDays(today, -(isoWeekday(today) - 1));
+  switch (input.preset) {
+    case "today":
+      return [today, today];
+    case "yesterday":
+      return [addDays(today, -1), addDays(today, -1)];
+    case "thisWeek":
+      return [weekStart, today];
+    case "lastWeek":
+      return [addDays(weekStart, -7), addDays(weekStart, -1)];
+    case "thisMonth":
+      return [monthStart, today];
+    case "lastMonth": {
+      const lastMonthEnd = addDays(monthStart, -1);
+      return [`${lastMonthEnd.slice(0, 8)}01`, lastMonthEnd];
+    }
+    case "thisYear":
+      return [`${today.slice(0, 4)}-01-01`, today];
+  }
+}
+function periodFromDays(from, to, timezone) {
+  const days = daysBetween(from, to) + 1;
+  if (days > MAX_PERIOD_DAYS) {
+    throw new PeriodError(`A period may cover at most ${MAX_PERIOD_DAYS} days (two years); ${from} to ${to} is ${days} days.`);
+  }
+  return {
+    from,
+    to,
+    timezone,
+    start: startOfLocalDay(from, timezone),
+    end: startOfLocalDay(addDays(to, 1), timezone),
+    days
+  };
+}
+function previousPeriod(period) {
+  const to = addDays(period.from, -1);
+  const from = addDays(to, -(period.days - 1));
+  return periodFromDays(from, to, period.timezone);
+}
+
+// src/query.ts
+var MAX_MEASURES = 4;
+var MAX_GROUP_BY = 2;
+var MAX_LIMIT = 100;
+var DEFAULT_LIMIT = 20;
+var PERIOD_PRESETS = [
+  "today",
+  "yesterday",
+  "thisWeek",
+  "lastWeek",
+  "thisMonth",
+  "lastMonth",
+  "thisYear"
+];
+var isoDate = z.iso.date().describe("A date, YYYY-MM-DD.");
+var periodSchema = z.union([
+  z.object({
+    last: z.object({
+      days: z.number().int().min(1).max(MAX_PERIOD_DAYS).describe("Number of days, ending today.")
+    })
+  }),
+  z.object({ from: isoDate, to: isoDate.describe("Last day, inclusive.") }),
+  z.object({ preset: z.enum(PERIOD_PRESETS) })
+]).describe("Which days to count, in the organization timezone. Defaults to the last 30 days. At most two years.");
+function describeList(entries) {
+  return entries.map(([key, entry]) => `${key}: ${entry.label}${entry.description ? ` (${entry.description})` : ""}`).join(" · ");
+}
+function nonEmpty(values) {
+  const [first, ...rest] = values;
+  return first === undefined ? null : [first, ...rest];
+}
+function filterSchema(key, dim) {
+  const dimension = z.literal(key);
+  const description = `${dim.label}${dim.description ? `: ${dim.description}` : ""}`;
+  const emptiness = z.object({
+    dimension,
+    op: z.enum(["isEmpty", "isNotEmpty"])
+  });
+  switch (dim.category) {
+    case "closed": {
+      const labels = Object.entries(dim.values).map(([value, label]) => [value, { label }]);
+      const keys = nonEmpty(labels.map(([value]) => value));
+      if (!keys)
+        throw new Error(`Dimension ${key} lists no values`);
+      const values = z.array(z.enum(keys)).min(1).describe(describeList(labels));
+      return z.discriminatedUnion("op", [
+        z.object({ dimension, op: z.enum(["in", "notIn"]), values }),
+        emptiness
+      ]).describe(description);
+    }
+    case "open":
+      return z.discriminatedUnion("op", [
+        z.object({
+          dimension,
+          op: z.enum(["in", "notIn"]),
+          values: z.array(z.string()).min(1).describe("Keys or names; names match case-insensitively.")
+        }),
+        emptiness
+      ]).describe(description);
+    case "numeric":
+      return z.discriminatedUnion("op", [
+        z.object({
+          dimension,
+          op: z.literal("between"),
+          from: z.number(),
+          to: z.number()
+        }),
+        emptiness
+      ]).describe(`${description} (inclusive range)`);
+    case "time":
+      return z.discriminatedUnion("op", [
+        z.object({
+          dimension,
+          op: z.literal("between"),
+          from: isoDate,
+          to: isoDate
+        }),
+        emptiness
+      ]).describe(`${description} (bucket start dates, inclusive)`);
+  }
+}
+function datasetQuerySchema(dataset) {
+  const measures = Object.entries(dataset.measures);
+  const dimensions = Object.entries(dataset.dimensions);
+  const groupable = dimensions.filter(([, dim]) => dim.groupable);
+  const filterable = dimensions.filter(([, dim]) => dim.filterable);
+  const measureKeys = nonEmpty(measures.map(([key]) => key));
+  if (!measureKeys)
+    throw new Error(`Dataset ${dataset.key} has no measures`);
+  const groupKeys = nonEmpty(groupable.map(([key]) => key));
+  const timeKeys = nonEmpty(Object.keys(dataset.time));
+  const sortKeys = nonEmpty([...measureKeys, ...groupKeys ?? []]) ?? measureKeys;
+  const notes = groupable.filter(([, dim]) => dim.kind === "manyToMany" && dim.note).map(([key, dim]) => `${key}: ${dim.kind === "manyToMany" ? dim.note : ""}`);
+  const [firstFilter, ...otherFilters] = filterable.map(([key, dim]) => filterSchema(key, dim));
+  return z.object({
+    dataset: z.literal(dataset.key).describe(`${dataset.label}. ${dataset.description}`),
+    measures: z.array(z.enum(measureKeys)).min(1).max(MAX_MEASURES).describe(describeList(measures)),
+    ...groupKeys && {
+      groupBy: z.array(z.enum(groupKeys)).max(MAX_GROUP_BY).optional().describe([describeList(groupable), ...notes].join(`
+`))
+    },
+    ...firstFilter && {
+      filters: z.array(z.discriminatedUnion("dimension", [firstFilter, ...otherFilters])).optional().describe("Every filter must match.")
+    },
+    period: periodSchema.nullish(),
+    ...timeKeys && {
+      time: z.enum(timeKeys).optional().describe(`Which time field the period applies to; time dimensions name their own. Defaults to ${dataset.defaultTime}. ${describeList(Object.entries(dataset.time))}`)
+    },
+    compareToPrevious: z.boolean().optional().describe("Also return the previous period of the same length."),
+    sort: z.object({
+      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}.`)
+  }).superRefine((query, context) => {
+    const { groupBy } = query;
+    const by = query.sort?.by;
+    const returned = [...query.measures, ...groupBy ?? []];
+    if (by !== undefined && !returned.includes(by)) {
+      context.addIssue({
+        code: "custom",
+        path: ["sort", "by"],
+        message: `Sort by one of the asked measures or grouped dimensions: ${returned.join(", ")}`
+      });
+    }
+  });
+}
+function buildQuerySchema(datasets) {
+  const [first, ...rest] = datasets.map(datasetQuerySchema);
+  if (!first)
+    throw new Error("querySchema needs at least one dataset");
+  return z.discriminatedUnion("dataset", [first, ...rest]);
+}
+var periodOutput = z.object({
+  from: z.string(),
+  to: z.string(),
+  timezone: z.string()
+});
+var measureValue = z.number().nullable();
+var dimensionValue = z.object({
+  key: z.union([z.string(), z.number()]).nullable(),
+  label: z.string()
+});
+function resultSchemaOf(row, totals) {
+  return z.object({
+    period: periodOutput,
+    rows: z.array(row),
+    totals,
+    previous: z.object({ period: periodOutput, rows: z.array(row), totals }).optional(),
+    notes: z.array(z.string()),
+    truncated: z.boolean()
+  });
+}
+function datasetResultSchema(dataset) {
+  const measures = Object.fromEntries(Object.entries(dataset.measures).map(([key, entry]) => [
+    key,
+    measureValue.optional().describe(entry.label)
+  ]));
+  const dimensions = Object.fromEntries(Object.entries(dataset.dimensions).map(([key, entry]) => [
+    key,
+    dimensionValue.optional().describe(entry.label)
+  ]));
+  return resultSchemaOf(z.object({ ...dimensions, ...measures }), z.object(measures));
+}
+var AnalyticsResultSchema2 = resultSchemaOf(z.record(z.string(), z.union([dimensionValue, measureValue])), z.record(z.string(), measureValue));
+
+// src/analytics.ts
+import { z as z2 } from "zod";
+
+// src/plan.ts
+function normalizeQuery(dataset, parsed) {
+  const filters = (parsed.filters ?? []).map((filter) => filter.op === "in" || filter.op === "notIn" ? { ...filter, values: [...new Set(filter.values)] } : filter);
+  return {
+    dataset: dataset.key,
+    measures: [...new Set(parsed.measures)],
+    groupBy: [...new Set(parsed.groupBy ?? [])],
+    filters,
+    period: parsed.period ?? DEFAULT_PERIOD,
+    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
+  };
+}
+var param = (value) => ({ kind: "param", value });
+var and = (items) => items.length === 1 && items[0] ? items[0] : { kind: "logical", op: "and", items };
+function measureOf(dataset, key) {
+  const entry = dataset.measures[key];
+  if (!entry)
+    throw new Error(`Dataset ${dataset.key} has no measure ${key}`);
+  return entry;
+}
+function dimensionOf(dataset, key) {
+  const entry = dataset.dimensions[key];
+  if (!entry)
+    throw new Error(`Dataset ${dataset.key} has no dimension ${key}`);
+  return entry;
+}
+function measureNode(dataset, key) {
+  const entry = measureOf(dataset, key);
+  switch (entry.kind) {
+    case "aggregate":
+      return entry.node;
+    case "share": {
+      const numeratorWhere = entry.denominator ? and([entry.numerator, entry.denominator]) : entry.numerator;
+      return {
+        kind: "arithmetic",
+        op: "/",
+        left: {
+          kind: "aggregate",
+          fn: "count",
+          arg: null,
+          where: numeratorWhere
+        },
+        right: {
+          kind: "aggregate",
+          fn: "count",
+          arg: null,
+          where: entry.denominator
+        }
+      };
+    }
+    case "ratio":
+      return {
+        kind: "arithmetic",
+        op: "/",
+        left: measureNode(dataset, entry.numerator),
+        right: measureNode(dataset, entry.denominator)
+      };
+  }
+}
+function dimensionNodes(dataset, key, timezone) {
+  const entry = dimensionOf(dataset, key);
+  switch (entry.kind) {
+    case "enum":
+    case "computed":
+    case "number":
+      return { key: entry.expr, label: null, virtualJoin: null };
+    case "relation":
+      return { key: entry.key, label: entry.name, virtualJoin: null };
+    case "manyToMany":
+      return {
+        key: entry.key,
+        label: entry.name,
+        virtualJoin: { table: entry.table, type: "left", on: entry.on }
+      };
+    case "timeBucket":
+    case "timePart": {
+      const field = dataset.time[entry.time];
+      if (!field)
+        throw new Error(`Dataset ${dataset.key} has no time field ${entry.time}`);
+      return {
+        key: entry.kind === "timeBucket" ? {
+          kind: "timeBucket",
+          unit: entry.unit,
+          item: field.column,
+          timezone
+        } : {
+          kind: "timePart",
+          part: entry.part,
+          item: field.column,
+          timezone
+        },
+        label: null,
+        virtualJoin: null
+      };
+    }
+  }
+}
+function baseWhere(dataset, tenant, period) {
+  const where = [
+    {
+      kind: "compare",
+      op: "=",
+      left: dataset.tenantColumn,
+      right: param(tenant)
+    }
+  ];
+  if (dataset.scope)
+    where.push(dataset.scope);
+  if (period) {
+    const field = dataset.time[period.time];
+    if (!field)
+      throw new Error(`Dataset ${dataset.key} has no time field ${period.time}`);
+    where.push({
+      kind: "compare",
+      op: ">=",
+      left: field.column,
+      right: param(period.start)
+    }, { kind: "compare", op: "<", left: field.column, right: param(period.end) });
+  }
+  return where;
+}
+function filterNode(dataset, filter, context) {
+  const entry = dimensionOf(dataset, filter.dimension);
+  const { key } = dimensionNodes(dataset, filter.dimension, context.timezone);
+  if (entry.kind === "manyToMany") {
+    const linked = (condition, negated) => ({
+      kind: "exists",
+      table: entry.table,
+      where: condition ? and([entry.on, condition]) : entry.on,
+      negated
+    });
+    switch (filter.op) {
+      case "isEmpty":
+      case "isNotEmpty":
+        return linked(null, filter.op === "isEmpty");
+      case "between":
+        throw new Error(`${filter.dimension} does not support between`);
+      case "in":
+      case "notIn": {
+        const values = context.resolvedValues.get(filter.dimension) ?? filter.values;
+        const matches = {
+          kind: "in",
+          item: key,
+          values: values.map(param),
+          negated: false
+        };
+        return linked(matches, filter.op === "notIn");
+      }
+    }
+  }
+  switch (filter.op) {
+    case "isEmpty":
+      return { kind: "isNull", item: key, negated: false };
+    case "isNotEmpty":
+      return { kind: "isNull", item: key, negated: true };
+    case "between":
+      return and([
+        { kind: "compare", op: ">=", left: key, right: param(filter.from) },
+        { kind: "compare", op: "<=", left: key, right: param(filter.to) }
+      ]);
+    case "in":
+    case "notIn": {
+      const values = context.resolvedValues.get(filter.dimension) ?? filter.values;
+      const list = {
+        kind: "in",
+        item: key,
+        values: values.map(param),
+        negated: filter.op === "notIn"
+      };
+      if (filter.op === "in")
+        return list;
+      return {
+        kind: "logical",
+        op: "or",
+        items: [list, { kind: "isNull", item: key, negated: false }]
+      };
+    }
+  }
+}
+var columnAlias = {
+  measure: (key) => `m_${key}`,
+  groupKey: (key) => `g_${key}`,
+  groupLabel: (key) => `g_${key}__label`
+};
+function planQuery(dataset, query, context, grouped) {
+  const select = [];
+  const groupBy = [];
+  const virtualJoins = [];
+  const groupKeys = grouped ? query.groupBy : [];
+  for (const key of groupKeys) {
+    const nodes = dimensionNodes(dataset, key, context.timezone);
+    if (nodes.virtualJoin)
+      virtualJoins.push(nodes.virtualJoin);
+    groupBy.push(select.length);
+    select.push({ alias: columnAlias.groupKey(key), node: nodes.key });
+    if (nodes.label) {
+      groupBy.push(select.length);
+      select.push({ alias: columnAlias.groupLabel(key), node: nodes.label });
+    }
+  }
+  for (const key of query.measures) {
+    select.push({
+      alias: columnAlias.measure(key),
+      node: measureNode(dataset, key)
+    });
+  }
+  const where = [
+    ...baseWhere(dataset, context.tenant, {
+      time: query.time,
+      start: context.period.start,
+      end: context.period.end
+    }),
+    ...query.filters.map((filter) => filterNode(dataset, filter, context))
+  ];
+  return {
+    from: dataset.from,
+    virtualJoins,
+    where,
+    select,
+    groupBy,
+    orderBy: groupKeys.length > 0 ? orderBy(dataset, query, select) : [],
+    limit: grouped && groupKeys.length > 0 ? query.limit + 1 : null,
+    now: context.now
+  };
+}
+function orderBy(dataset, query, select) {
+  const indexOf = (alias) => select.findIndex((item) => item.alias === alias);
+  const order = [];
+  const timeKey = query.groupBy.find((key) => {
+    const kind = dimensionOf(dataset, key).kind;
+    return kind === "timeBucket" || kind === "timePart";
+  });
+  const sort = query.sort ?? (timeKey ? { by: timeKey, direction: "asc" } : { by: query.measures[0] ?? "", direction: "desc" });
+  const sortIndex = sort.by in dataset.measures ? indexOf(columnAlias.measure(sort.by)) : indexOf(columnAlias.groupKey(sort.by));
+  if (sortIndex >= 0)
+    order.push({ index: sortIndex, direction: sort.direction });
+  for (const key of query.groupBy) {
+    const index = indexOf(columnAlias.groupKey(key));
+    if (index >= 0 && index !== sortIndex)
+      order.push({ index, direction: "asc" });
+  }
+  return order;
+}
+function planLookup(dataset, dimensionKey, tenant, values, now) {
+  const nodes = dimensionNodes(dataset, dimensionKey, "UTC");
+  const label = nodes.label ?? nodes.key;
+  const where = baseWhere(dataset, tenant, null);
+  where.push({ kind: "isNull", item: nodes.key, negated: true });
+  if (values) {
+    where.push({
+      kind: "logical",
+      op: "or",
+      items: [
+        {
+          kind: "in",
+          item: { kind: "toText", item: nodes.key },
+          values: values.map(param),
+          negated: false
+        },
+        {
+          kind: "in",
+          item: { kind: "lower", item: label },
+          values: values.map((value) => param(value.toLowerCase())),
+          negated: false
+        }
+      ]
+    });
+  }
+  return {
+    from: dataset.from,
+    virtualJoins: nodes.virtualJoin ? [nodes.virtualJoin] : [],
+    where,
+    select: [
+      { alias: "key", node: nodes.key },
+      { alias: "label", node: label }
+    ],
+    groupBy: [0, 1],
+    orderBy: [{ index: 1, direction: "asc" }],
+    limit: values ? 500 : 50,
+    now
+  };
+}
+var WEEKDAYS = [
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday",
+  "Sunday"
+];
+function decodeKey(dimension, raw, dialect) {
+  if (raw === null || raw === undefined)
+    return null;
+  switch (dimension.kind) {
+    case "number":
+    case "timePart":
+      return dialect.decodeNumber(raw);
+    case "relation":
+    case "manyToMany":
+      if (typeof raw === "string")
+        return raw;
+      return dialect.decodeNumber(raw) ?? String(raw);
+    default:
+      return String(raw);
+  }
+}
+function labelOf(dimension, key, rawLabel) {
+  switch (dimension.kind) {
+    case "enum":
+    case "computed":
+      return key === null ? dimension.empty ?? "None" : dimension.values[String(key)] ?? String(key);
+    case "relation":
+    case "manyToMany":
+      if (key === null)
+        return dimension.empty ?? "None";
+      return rawLabel === null || rawLabel === undefined ? String(key) : String(rawLabel);
+    case "timeBucket":
+      if (key === null)
+        return "None";
+      return dimension.labelFor?.(String(key)) ?? String(key);
+    case "timePart":
+      if (typeof key !== "number")
+        return "None";
+      if (dimension.labelFor)
+        return dimension.labelFor(key);
+      return dimension.part === "isodow" ? WEEKDAYS[key - 1] ?? String(key) : `${String(key).padStart(2, "0")}:00`;
+    case "number":
+      if (typeof key !== "number")
+        return "None";
+      return dimension.labelFor?.(key) ?? String(key);
+  }
+}
+function shapeMeasures(dataset, measures, raw, dialect) {
+  const values = {};
+  for (const key of measures) {
+    const value = dialect.decodeNumber(raw[columnAlias.measure(key)]);
+    values[key] = measureOf(dataset, key).result === "count" ? value ?? 0 : value;
+  }
+  return values;
+}
+function shapeRows(dataset, query, rawRows, dialect) {
+  const truncated = query.groupBy.length > 0 && rawRows.length > query.limit;
+  const kept = truncated ? rawRows.slice(0, query.limit) : rawRows;
+  const rows = kept.map((raw) => {
+    const row = {};
+    for (const key of query.groupBy) {
+      const dimension = dimensionOf(dataset, key);
+      const value = decodeKey(dimension, raw[columnAlias.groupKey(key)], dialect);
+      row[key] = {
+        key: value,
+        label: labelOf(dimension, value, raw[columnAlias.groupLabel(key)])
+      };
+    }
+    return { ...row, ...shapeMeasures(dataset, query.measures, raw, dialect) };
+  });
+  return { rows, truncated };
+}
+function resultNotes(dataset, query) {
+  const notes = [];
+  for (const key of query.groupBy) {
+    const dimension = dimensionOf(dataset, key);
+    if (dimension.kind !== "manyToMany")
+      continue;
+    notes.push(dimension.note ?? `A row with several ${dimension.label.toLowerCase()} values counts once per value, so ${dimension.label.toLowerCase()} rows can add up to more than the total.`);
+  }
+  return notes;
+}
+
+// src/analytics.ts
+class AnalyticsError2 extends Error {
+  code;
+  name = "AnalyticsError";
+  details;
+  constructor(code, message, ...[details]) {
+    super(message);
+    this.code = code;
+    this.details = details;
+  }
+}
+function isAnalyticsError2(error, code) {
+  return error instanceof AnalyticsError2 && (code === undefined || error.code === code);
+}
+function createAnalytics2(options) {
+  const datasets = options.datasets;
+  const sourceNames = Object.keys(options.sources);
+  const byKey = new Map;
+  const sourceOf = 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 now = options.now ?? (() => new Date);
+  const querySchemas = new Map;
+  const resultSchemas = new Map;
+  const datasetOf = (key) => {
+    const dataset = byKey.get(key);
+    if (!dataset)
+      throw new AnalyticsError2("invalid_query", `Unknown dataset ${key}`, []);
+    return dataset;
+  };
+  const sourceFor = (dataset) => {
+    const source = sourceOf.get(dataset.key);
+    if (!source)
+      throw new Error(`No source for ${dataset.key}`);
+    return source;
+  };
+  const querySchemaFor = (keys) => {
+    const selected = keys ? keys.map(datasetOf) : datasets;
+    const selectionKey = selected.map((dataset) => dataset.key).sort().join(",");
+    let schema = querySchemas.get(selectionKey);
+    if (!schema) {
+      schema = buildQuerySchema(selected);
+      querySchemas.set(selectionKey, schema);
+    }
+    return schema;
+  };
+  const resultSchemaFor = (key) => {
+    let schema = resultSchemas.get(key);
+    if (!schema) {
+      schema = datasetResultSchema(datasetOf(key));
+      resultSchemas.set(key, schema);
+    }
+    return schema;
+  };
+  const allowedDatasets = async (ctx) => {
+    const { authorize } = options;
+    if (!authorize)
+      return datasets;
+    const allowed = await Promise.all(datasets.map((dataset) => authorize(dataset, ctx)));
+    return datasets.filter((_, index) => allowed[index]);
+  };
+  const querySchemaForCtx = async (ctx) => {
+    const allowed = await allowedDatasets(ctx);
+    if (allowed.length === 0) {
+      throw new AnalyticsError2("forbidden", "No dataset is allowed");
+    }
+    return querySchemaFor(allowed.map((dataset) => dataset.key));
+  };
+  const prepare = async (input, ctx) => {
+    const parsed = querySchemaFor(undefined).safeParse(input);
+    if (!parsed.success) {
+      throw new AnalyticsError2("invalid_query", `Invalid analytics query: ${z2.prettifyError(parsed.error)}`, parsed.error.issues);
+    }
+    const dataset = datasetOf(parsed.data.dataset);
+    if (options.authorize && !await options.authorize(dataset, ctx)) {
+      throw new AnalyticsError2("forbidden", `Not allowed to query ${dataset.key}`);
+    }
+    const tenant = options.tenant(ctx);
+    if (tenant === null || tenant === undefined || tenant === "") {
+      throw new AnalyticsError2("missing_tenant", "Refusing to query without a tenant");
+    }
+    const timezone = await options.timezone?.(ctx) || "UTC";
+    if (!isValidTimezone(timezone)) {
+      throw new AnalyticsError2("invalid_timezone", `Unknown timezone ${timezone}`);
+    }
+    const query = normalizeQuery(dataset, parsed.data);
+    const at = now();
+    let period;
+    try {
+      period = resolvePeriod(query.period, timezone, at);
+    } catch (error) {
+      if (error instanceof PeriodError) {
+        throw new AnalyticsError2("invalid_period", error.message);
+      }
+      throw error;
+    }
+    const previous = query.compareToPrevious ? previousPeriod(period) : null;
+    return { dataset, query, tenant, timezone, period, previous, now: at };
+  };
+  const runQuery = async (input, ctx) => {
+    const { dataset, query, tenant, timezone, period, previous, now } = await prepare(input, ctx);
+    const source = sourceFor(dataset);
+    const { dialect } = source;
+    const run = (statement) => source.execute(dialect.compile(statement));
+    const resolvedValues = await resolveOpenValues(dataset, query, tenant, now, run, dialect);
+    const runPeriod = async (target) => {
+      const statements = periodStatements(dataset, query, {
+        tenant,
+        timezone,
+        period: target,
+        now,
+        resolvedValues
+      });
+      const [rawRows, rawTotals] = await Promise.all([
+        run(statements.rows),
+        statements.totals ? run(statements.totals) : null
+      ]);
+      const { rows, truncated } = shapeRows(dataset, query, rawRows, dialect);
+      const totalsRow = (rawTotals ?? rawRows)[0] ?? {};
+      const totals = shapeMeasures(dataset, query.measures, totalsRow, dialect);
+      const periodOut = { from: target.from, to: target.to, timezone };
+      return { period: periodOut, rows, totals, truncated };
+    };
+    const [current, before] = await Promise.all([
+      runPeriod(period),
+      previous ? runPeriod(previous) : null
+    ]);
+    return {
+      period: current.period,
+      rows: current.rows,
+      totals: current.totals,
+      ...before && {
+        previous: {
+          period: before.period,
+          rows: before.rows,
+          totals: before.totals
+        }
+      },
+      notes: resultNotes(dataset, query),
+      truncated: current.truncated
+    };
+  };
+  const datasetKeyOf = (input) => {
+    if (typeof input !== "object" || input === null)
+      return null;
+    const key = "dataset" in input ? input.dataset : undefined;
+    return typeof key === "string" && byKey.has(key) ? key : null;
+  };
+  const report = (event, ctx) => {
+    try {
+      Promise.resolve(options.onQuery?.(event, ctx)).catch(() => {});
+    } catch {}
+  };
+  const query = async (input, ctx) => {
+    const startedAt = performance.now();
+    const dataset = datasetKeyOf(input);
+    const durationMs = () => Math.round(performance.now() - startedAt);
+    try {
+      const result = await runQuery(input, ctx);
+      report({
+        dataset,
+        durationMs: durationMs(),
+        rows: result.rows.length,
+        outcome: "success"
+      }, ctx);
+      return result;
+    } catch (error) {
+      report({ dataset, durationMs: durationMs(), rows: 0, outcome: "error", error }, ctx);
+      throw error;
+    }
+  };
+  const explain = async (input, ctx) => {
+    const { dataset, query, tenant, timezone, period, previous, now } = await prepare(input, ctx);
+    const { dialect } = sourceFor(dataset);
+    const compiled = [];
+    for (const target of previous ? [period, previous] : [period]) {
+      const statements = periodStatements(dataset, query, {
+        tenant,
+        timezone,
+        period: target,
+        now,
+        resolvedValues: new Map
+      });
+      compiled.push(dialect.compile(statements.rows));
+      if (statements.totals)
+        compiled.push(dialect.compile(statements.totals));
+    }
+    return compiled;
+  };
+  return {
+    datasets: options.datasets,
+    query,
+    explain,
+    querySchema: (schemaOptions) => schemaOptions && ("ctx" in schemaOptions) ? querySchemaForCtx(schemaOptions.ctx) : querySchemaFor(schemaOptions?.datasets),
+    resultSchema: (key) => resultSchemaFor(key),
+    listDatasets: async (ctx) => (await allowedDatasets(ctx)).map((dataset) => catalogEntry(dataset))
+  };
+}
+function periodStatements(dataset, query, context) {
+  const grouped = query.groupBy.length > 0;
+  return {
+    rows: planQuery(dataset, query, context, true),
+    totals: grouped ? planQuery(dataset, query, context, false) : null
+  };
+}
+function resolveSource(dataset, sources, sourceNames) {
+  const name = dataset.source ?? (sourceNames.length === 1 ? sourceNames[0] : undefined);
+  if (!name) {
+    throw new Error(`Dataset ${dataset.key} names no source, and there are several: ${sourceNames.join(", ")}`);
+  }
+  const source = sources[name];
+  if (!source)
+    throw new Error(`Dataset ${dataset.key} uses unknown source ${name}`);
+  return source;
+}
+function compileEverything(dataset, dialect) {
+  const now = new Date(0);
+  const context = {
+    tenant: "tenant",
+    timezone: "UTC",
+    period: resolvePeriod({ last: { days: 1 } }, "UTC", now),
+    now,
+    resolvedValues: new Map
+  };
+  const measures = Object.keys(dataset.measures);
+  const base = normalizeQuery(dataset, { dataset: dataset.key, measures });
+  try {
+    dialect.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));
+      }
+      if (dimension.filterable) {
+        const filter = dimension.category === "numeric" ? { dimension: key, op: "between", from: 0, to: 1 } : dimension.category === "time" ? {
+          dimension: key,
+          op: "between",
+          from: "2000-01-01",
+          to: "2000-01-02"
+        } : { dimension: key, op: "in", values: ["value"] };
+        dialect.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}`);
+  }
+}
+async function resolveOpenValues(dataset, query, tenant, now, run, dialect) {
+  const resolved = new Map;
+  for (const filter of query.filters) {
+    if (filter.op !== "in" && filter.op !== "notIn")
+      continue;
+    const dimension = dataset.dimensions[filter.dimension];
+    if (dimension?.category !== "open")
+      continue;
+    const wanted = filter.values.map(String);
+    const found = await run(planLookup(dataset, filter.dimension, tenant, wanted, now));
+    const keys = new Set;
+    const unknown = [];
+    for (const value of wanted) {
+      const matches = found.filter((row) => String(row.key) === value || String(row.label ?? "").toLowerCase() === value.toLowerCase());
+      if (matches.length === 0)
+        unknown.push(value);
+      for (const match of matches)
+        keys.add(decodeKey2(match.key, dialect));
+    }
+    if (unknown.length > 0) {
+      const valid = (await run(planLookup(dataset, filter.dimension, tenant, null, now))).map((row) => ({
+        key: String(decodeKey2(row.key, dialect)),
+        label: String(row.label ?? row.key)
+      }));
+      const list = valid.map((entry) => `${entry.label} (${entry.key})`).join(", ");
+      const quoted = unknown.map((value) => `"${value}"`).join(", ");
+      throw new AnalyticsError2("unknown_value", `Unknown ${dimension.label.toLowerCase()}: ${quoted}. Valid values: ${list || "none"}.`, { dimension: filter.dimension, unknown, valid });
+    }
+    resolved.set(filter.dimension, [...keys]);
+  }
+  return resolved;
+}
+function decodeKey2(value, dialect) {
+  if (typeof value === "string")
+    return value;
+  return dialect.decodeNumber(value) ?? String(value);
+}
+function catalogEntry(dataset) {
+  return {
+    key: dataset.key,
+    label: dataset.label,
+    description: dataset.description,
+    time: Object.entries(dataset.time).map(([key, field]) => ({
+      key,
+      label: field.label
+    })),
+    measures: Object.entries(dataset.measures).map(([key, entry]) => ({
+      key,
+      label: entry.label,
+      description: entry.description
+    })),
+    dimensions: Object.entries(dataset.dimensions).map(([key, entry]) => ({
+      key,
+      label: entry.label,
+      description: entry.description,
+      kind: entry.kind,
+      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
+    }))
+  };
+}
+
+// src/dataset.ts
+function aggregate(result, fn, arg, options) {
+  return {
+    kind: "aggregate",
+    result,
+    label: options.label,
+    description: options.description,
+    node: {
+      kind: "aggregate",
+      fn,
+      arg: arg?.node ?? null,
+      where: options.where?.node ?? null
+    }
+  };
+}
+var measure2 = {
+  count(options) {
+    return aggregate("count", "count", null, options);
+  },
+  countWhere(condition, options) {
+    return aggregate("count", "count", null, { ...options, where: condition });
+  },
+  countDistinct(expr, options) {
+    return aggregate("count", "countDistinct", expr, options);
+  },
+  sum(expr, options) {
+    return aggregate("number", "sum", expr, options);
+  },
+  avg(expr, options) {
+    return aggregate("number", "avg", expr, options);
+  },
+  median(expr, options) {
+    return aggregate("number", "median", expr, options);
+  },
+  share(options) {
+    return {
+      kind: "share",
+      result: "ratio",
+      label: options.label,
+      description: options.description,
+      numerator: options.numerator.node,
+      denominator: options.denominator?.node ?? null
+    };
+  },
+  ratio(numerator, denominator, options) {
+    return {
+      kind: "ratio",
+      result: "ratio",
+      label: options.label,
+      description: options.description,
+      numerator,
+      denominator
+    };
+  }
+};
+function base(options) {
+  return {
+    label: options.label,
+    description: options.description,
+    groupable: options.filterOnly !== true,
+    filterable: options.groupOnly !== true
+  };
+}
+function withAccess(_options, dimension) {
+  return dimension;
+}
+var dimension2 = {
+  enum(expr, values, options) {
+    for (const value of Object.values(values)) {
+      if (!(value in options.labels)) {
+        throw new Error(`${options.label}: the value ${value} has no label`);
+      }
+    }
+    return withAccess(options, {
+      ...base(options),
+      category: "closed",
+      kind: "enum",
+      expr: expr.node,
+      values: options.labels,
+      empty: options.empty
+    });
+  },
+  computed(options) {
+    return withAccess(options, {
+      ...base(options),
+      category: "closed",
+      kind: "computed",
+      expr: options.expr.node,
+      values: options.values,
+      empty: options.empty
+    });
+  },
+  relation(options) {
+    return withAccess(options, {
+      ...base(options),
+      category: "open",
+      kind: "relation",
+      key: options.key.node,
+      name: options.name.node,
+      empty: options.empty
+    });
+  },
+  manyToMany(options) {
+    return withAccess(options, {
+      ...base(options),
+      category: "open",
+      kind: "manyToMany",
+      table: options.through.table.ref,
+      on: options.through.on.node,
+      key: options.through.key.node,
+      name: options.through.name.node,
+      empty: options.empty,
+      note: options.note
+    });
+  },
+  number(expr, options) {
+    return withAccess(options, {
+      ...base(options),
+      category: "numeric",
+      kind: "number",
+      expr: expr.node,
+      labelFor: options.labelFor
+    });
+  },
+  timeBucket(time, unit, options) {
+    return withAccess(options, {
+      ...base({
+        ...options,
+        label: options?.label ?? unit[0]?.toUpperCase() + unit.slice(1)
+      }),
+      category: "time",
+      kind: "timeBucket",
+      time,
+      unit,
+      labelFor: options?.labelFor
+    });
+  },
+  timePart(time, part, options) {
+    return withAccess(options, {
+      ...base({
+        ...options,
+        label: options?.label ?? (part === "isodow" ? "Weekday" : "Hour")
+      }),
+      category: "numeric",
+      kind: "timePart",
+      time,
+      part,
+      labelFor: options?.labelFor
+    });
+  }
+};
+function defineDataset2(definition) {
+  const timeEntries = Object.entries(definition.time);
+  const firstTime = timeEntries[0];
+  if (!firstTime) {
+    throw new Error(`Dataset ${definition.key}: declare at least one time field`);
+  }
+  const time = Object.fromEntries(timeEntries.map(([key, field]) => [
+    key,
+    { column: field.column.node, label: field.label }
+  ]));
+  const dataset = {
+    key: definition.key,
+    label: definition.label,
+    description: definition.description,
+    from: definition.from.ref,
+    source: definition.source,
+    tenantColumn: definition.tenantColumn.node,
+    scope: definition.scope?.node ?? null,
+    time,
+    defaultTime: definition.defaultTime ?? firstTime[0],
+    measures: definition.measures,
+    dimensions: definition.dimensions
+  };
+  return validateDataset(dataset);
+}
+function validateDataset(dataset) {
+  const fail = (message) => {
+    throw new Error(`Dataset ${dataset.key}: ${message}`);
+  };
+  const check = (node, where, extraRoots = []) => {
+    visitScoped(node, [dataset.from, ...extraRoots], (inner, roots) => {
+      if (inner.kind === "column") {
+        const root = rootOf(inner.table);
+        if (!roots.includes(root)) {
+          fail(`${where} reads ${inner.table.name}.${inner.column}, which is not joined to ${dataset.from.name}`);
+        }
+      }
+    });
+  };
+  check(dataset.tenantColumn, "tenantColumn");
+  if (dataset.scope)
+    check(dataset.scope, "scope");
+  for (const [key, field] of Object.entries(dataset.time)) {
+    check(field.column, `time field ${key}`);
+  }
+  const measures = dataset.measures;
+  for (const [key, entry] of Object.entries(measures)) {
+    if (entry.kind === "aggregate")
+      check(entry.node, `measure ${key}`);
+    if (entry.kind === "share") {
+      check(entry.numerator, `measure ${key}`);
+      if (entry.denominator)
+        check(entry.denominator, `measure ${key}`);
+    }
+    if (entry.kind === "ratio")
+      checkRatio(measures, key, [], fail);
+  }
+  const dimensions = dataset.dimensions;
+  for (const [key, entry] of Object.entries(dimensions)) {
+    const where = `dimension ${key}`;
+    switch (entry.kind) {
+      case "enum":
+      case "number":
+        check(entry.expr, where);
+        break;
+      case "computed":
+        check(entry.expr, where);
+        for (const value of plainCaseValues(entry.expr)) {
+          if (!(value in entry.values)) {
+            fail(`${where} can produce "${value}", which is missing from its values`);
+          }
+        }
+        break;
+      case "relation":
+        check(entry.key, where);
+        check(entry.name, where);
+        break;
+      case "manyToMany":
+        if (entry.table.join) {
+          fail(`${where}: through.table must be a standalone table(), not a join`);
+        }
+        check(entry.on, where, [entry.table]);
+        check(entry.key, where, [entry.table]);
+        check(entry.name, where, [entry.table]);
+        break;
+      case "timeBucket":
+      case "timePart":
+        if (!(entry.time in dataset.time))
+          fail(`${where} names unknown time field ${entry.time}`);
+        break;
+    }
+  }
+  return dataset;
+}
+function checkRatio(measures, key, path, fail) {
+  if (path.includes(key))
+    fail(`ratio measures form a cycle: ${[...path, key].join(" -> ")}`);
+  const entry = measures[key];
+  if (!entry)
+    fail(`ratio measure ${path.at(-1)} names unknown measure ${key}`);
+  if (entry?.kind !== "ratio")
+    return;
+  checkRatio(measures, entry.numerator, [...path, key], fail);
+  checkRatio(measures, entry.denominator, [...path, key], fail);
+}
+function visitScoped(node, roots, visit, seenJoins = new Set) {
+  visit(node, roots);
+  if (node.kind === "exists") {
+    visitScoped(node.where, [...roots, node.table], visit, seenJoins);
+    return;
+  }
+  if (node.kind === "column" && node.table.join && !seenJoins.has(node.table)) {
+    seenJoins.add(node.table);
+    visitScoped(node.table.join.on, roots, visit, seenJoins);
+    return;
+  }
+  for (const child of directChildren(node)) {
+    visitScoped(child, roots, visit, seenJoins);
+  }
+}
+function plainCaseValues(node) {
+  if (node.kind === "param" && typeof node.value === "string")
+    return [node.value];
+  if (node.kind === "case") {
+    return [
+      ...node.branches.flatMap((branch) => plainCaseValues(branch.result)),
+      ...node.otherwise ? plainCaseValues(node.otherwise) : []
+    ];
+  }
+  if (node.kind === "coalesce")
+    return node.items.flatMap(plainCaseValues);
+  return [];
+}
+
+export { MAX_MEASURES, AnalyticsResultSchema2, AnalyticsError2, isAnalyticsError2, createAnalytics2, measure2, dimension2, defineDataset2 };