measurr 0.5.0 → 0.7.0

package/README.md

@@ -7,8 +7,8 @@ returns shaped, typed rows.
 
 - No SQL text in definitions: datasets are built from typed expression builders, so a
   renamed column, `avg` over a string or `between` on an enum fails typecheck.
-- Database-neutral definitions: dialects plug in through the `Dialect` interface, and Postgres
-  ships today (`measurr/postgres`).
+- Database-neutral definitions: dialects plug in through the `Dialect` interface. Postgres
+  (`measurr/postgres`) and ClickHouse (`measurr/clickhouse`) ship today.
 - Tenant-scoped by construction: the engine adds the tenant filter to every statement and
   refuses to run without a tenant. A caller can be scoped to one tenant or a list of them;
   platform admins can query every tenant only through an explicit `allTenants` value that no
@@ -242,6 +242,95 @@ toLeaderboard(result, { by: 'region', measure: 'revenue' }) // ranked rows with
 - `toDistribution`'s `total` is the measure over every row, so many-to-many shares can add up to
   more than 1. `toPivot` sorts numeric keys (weekdays, hours).
 
+### Presentation
+
+`presentKpi`, `presentTimeseries`, `presentDistribution` and `presentLeaderboard` turn a result
+into the wire outputs a dashboard draws (`KpiOutput`, `TimeSeriesOutput`, `DistributionOutput`,
+`LeaderboardOutput`; `TableOutput` and `PivotOutput` for outputs you build yourself). A missing
+value is 0, keys are strings, and the caller picks labels, units and chart types:
+
+```ts
+presentKpi(result, 'paidShare', { label: 'Paid', percent: true })
+// { kind: 'kpi', value: 25, unit: 'PERCENTAGE', label: 'Paid' }
+
+presentTimeseries(result, {
+	bucket: 'day', measure: 'orders', series: 'status',
+	keys: { PAID: 'paid' }, // wire keys, by String(key); 'null' names the empty group
+	labels: { paid: 'Settled' }, // labels by wire key
+	chartType: 'line'
+})
+// points are { ts: Date, value }: ts is the bucket's local start date as UTC midnight
+
+presentDistribution(result, { by: 'tag', measure: 'orders', chartType: 'donut', order: ['t2'] })
+// total is what the segments add up to, percent is 0-100; keys order omits go last
+
+presentLeaderboard(result, { by: 'region', measure: 'orders', meta: (values) => ({ revenue: values.revenue }) })
+```
+
+`isKpi`, `isTimeSeries`, `isDistribution`, `isTable`, `isLeaderboard` and `isPivot` narrow a
+`MetricOutput`. The module is pure, so a browser bundle can import the types and guards.
+
+## Dashboard metrics
+
+`measurr/metrics` names the numbers a dashboard shows: one query and the output it is drawn
+in. The registry runs a batch for a caller and streams one chunk per metric.
+
+```ts
+import { createMetricRegistry, metricDefiner } from 'measurr/metrics'
+import { presentKpi, presentTimeseries } from 'measurr/shapes'
+
+// Types only, so metric modules need not import the analytics instance.
+export const defineMetric = metricDefiner<(typeof datasets)[number], Role>()
+
+const orderTrend = defineMetric({
+	key: 'orders.trend',
+	kind: 'timeseries',
+	description: 'Orders over time',
+	allowedRoles: ['owner', 'member'],
+	supportsTimeRange: true, // false for a snapshot: all time, no previous period
+	filterSchema: z.object({ status: z.enum(['OPEN', 'PAID']).optional() }),
+	query: ({ bucket, filters }) => ({
+		dataset: 'orders',
+		measures: ['orders'],
+		groupBy: [bucket],
+		filters: filters.status ? [{ dimension: 'status', op: 'in', values: [filters.status] }] : [],
+		limit: 100
+	}),
+	shape: (result, { bucket }) =>
+		presentTimeseries(result, { bucket, measure: 'orders', chartType: 'bar' })
+})
+
+export const metrics = createMetricRegistry({
+	analytics,
+	metrics: [orderTrend, orderCount] as const,
+	canRun: (metric, ctx) => ctx.isSuperAdmin || (metric.allowedRoles ?? []).includes(ctx.role),
+	onShapeError: (error, metric) => logger.error('metric.shape_failed', { key: metric.key, error })
+})
+
+const input = metrics.requestSchema.extend({ refresh: z.boolean().default(false) }).parse(body)
+for await (const chunk of metrics.run(input, ctx)) send(chunk)
+// { key, requestKey, result: { current, previous?, supportsTimeRange }, done }
+// or { key, requestKey, error, done }
+```
+
+- `query` returns the query without `period` or `compareToPrevious`. The registry counts the
+  local days `from` and `to` (instants) fall on in `analytics.timezone(ctx)`, all time without
+  them, and always all time for a snapshot. `compareToPrevious` adds the previous period, whose
+  series points are put on the current buckets so a chart overlays them.
+- `granularity` (hour to year, inferred from the range when omitted: day up to 31 days, week up
+  to 90, else month) picks `run.bucket`: `day`, `week` or `month`. Name time-bucket dimensions
+  after them so `groupBy: [bucket]` works.
+- A metric that `canRun` refuses (`'Access denied'`), whose filters do not parse with its
+  `filterSchema` (`'Invalid filters: ...'`), whose query fails (the engine's message) or whose
+  `shape` throws (`'The metric could not be drawn'`) fails alone. `done` marks the last chunk.
+- `metricDefiner<Datasets, Role, Extra>()` takes the app's own definition fields as `Extra`
+  (catalog metadata, UI hints for filters); the registry carries them to `canRun` and
+  `available` without reading them.
+- Keys and outputs stay literal: a chunk narrows to its metric by `key`, and
+  `MetricOutputOf<typeof metrics, 'orders.trend'>`, `MetricFiltersOf`, `MetricKeysOfKind` and
+  `registry.get(key)` are typed per metric. `registry.available(ctx)` lists what `canRun`
+  allows, for a catalog.
+
 ## Serving queries
 
 `measurr/handler` serves queries from any server framework:
@@ -266,6 +355,52 @@ try {
 }
 ```
 
+## Resolved measures
+
+Some numbers one statement cannot give: sprays per employee when the employees live in another
+database, an average per day of the period, a forecast. Declare such a measure with
+`measure.resolved` and give the code to `createAnalytics`. It stays a measure like any other:
+it is in the catalog and the schema, checked for access, scoped to the tenant and cached.
+
+```ts
+const sprays = defineDataset({
+	// ...
+	measures: {
+		sprays: measure.sum(status.col('sprays'), { label: 'Sprays' }),
+		spraysPerDay: measure.resolved({ label: 'Sprays per day', result: 'number', uses: ['sprays'] })
+	}
+})
+
+createAnalytics({
+	// ...
+	resolvers: {
+		sprays: {
+			spraysPerDay: ({ rows, totals, period }) => {
+				const days = 'all' in period ? null : daysBetween(period.from, period.to)
+				const perDay = (value: number | null) =>
+					value === null || days === null ? null : value / days
+				return { rows: rows.map(({ values }) => perDay(values.sprays)), totals: perDay(totals.sprays) }
+			}
+		}
+	}
+})
+```
+
+- `uses` names the measures of the same dataset the resolver reads. The database computes them
+  for every row and for the totals, even when the query does not ask for them, and the result
+  holds only what it asked for. A measure with no `uses` still gets one value per group.
+- The resolver gets the rows in order (`dimensions` for the grouped keys, `values` for the used
+  measures), the `totals`, `groupBy`, the `filters` (open-dimension labels resolved to keys),
+  the `period`, the `tenant` scope and `ctx`. It returns one value per row and one for the
+  totals. With `compareToPrevious` it is called once per period.
+- `createAnalytics` throws when a resolved measure has no resolver, and when `resolvers` names
+  anything else. A wrong number of values fails the query; a value that is not a finite number
+  is null, and a `count` result is 0 instead.
+- A resolved measure needs the access of the measures it uses, like a ratio. It cannot be sorted
+  by (the database limits the rows before the value exists), and `ratio` and `uses` cannot name
+  one.
+- The contract kit leaves resolved measures out: they are app code, so test them with it.
+
 ## Tenants and platform admins
 
 `tenant(ctx)` decides the scope of every statement, including the lookups that resolve filter
@@ -335,7 +470,7 @@ before any statement runs; a narrower scope is never ignored. `listDatasets(ctx)
 | Concept | What it is |
 | --- | --- |
 | Dataset | One fact table: tenant column (or `null`), optional scope, time fields, default period, measures, dimensions, source. |
-| Measure | `count`, `countWhere`, `countDistinct`, `sum`, `avg`, `median`, `share` (one condition over another) or `ratio` (one measure over another, after aggregation). Optionally restricted with `access`. |
+| Measure | `count`, `countWhere`, `countDistinct`, `sum`, `avg`, `median`, `share` (one condition over another), `ratio` (one measure over another, after aggregation) or `resolved` (computed by the app after the query runs). Optionally restricted with `access`. |
 | Dimension | `enum`, `computed` (closed value sets), `relation` (to-one), `manyToMany`, `number`, `timeBucket` (day, ISO week, month), `timePart` (ISO weekday, hour). Optionally restricted with `access`. |
 | Query | `dataset`, 1-4 `measures`, 0-2 `groupBy`, `filters`, `period`, `time`, `compareToPrevious`, `sort` (by an asked measure or grouped dimension), `limit` (1-100, default 20). |
 | Result | `{ period, rows, totals, previous?, notes, truncated }`; `period` is `{ from, to, timezone }` or `{ all: true, timezone }`. |
@@ -457,6 +592,34 @@ const main: AnalyticsSource = {
 }
 ```
 
+**`measurr/clickhouse`** `clickhouseDialect()`: typed `{pN:Type}` parameters, backquoted
+identifiers, `-If` and `-OrNull` aggregates (an empty group is null, as in Postgres), an exact
+interpolated median, `uniqExact` for distinct counts, and buckets with `toTimeZone`. Every
+statement ends with `SETTINGS join_use_nulls = 1, enable_positional_arguments = 1`, so a left
+join without a match gives null (an empty group) instead of an empty string. Pass the values
+with `toQueryParams`:
+
+```ts
+import { clickhouseDialect, toQueryParams } from 'measurr/clickhouse'
+
+const events: AnalyticsSource = {
+	dialect: clickhouseDialect(),
+	execute: async (statement) => {
+		const result = await clickhouse.query({
+			query: statement.text,
+			query_params: toQueryParams(statement),
+			format: 'JSONEachRow'
+		})
+		return result.json()
+	}
+}
+```
+
+ClickHouse cannot run correlated subqueries, so a dataset on it cannot use `exists` or filter
+by a many-to-many dimension (mark it `groupOnly`); `createAnalytics` fails at startup if it
+does. Time columns are `DateTime` or `DateTime64`, which hold instants. Tested against
+ClickHouse 24.
+
 **`measurr/postgres`** `postgresDialect({ timestamps })`: `$n` parameters (untyped,
 so Postgres infers them from the column, which keeps enum columns working), double-quoted
 identifiers, `FILTER (WHERE ...)`, `count(DISTINCT ...)`, `percentile_cont`, correlated
@@ -511,13 +674,17 @@ Kept stable for publishing: `createAnalytics` and its options (with `authorize`,
 `resultSchema`, `listDatasets`; `AnalyticsResultSchema`, `analyticsToolGuidance`,
 `AnalyticsQueryEvent`; `defineDataset` (with `defaultPeriod` and `tenantColumn: null`),
 `measure.*` and `dimension.*` (with `access`), `table` / `Table`, the expression builders; the
-`Dialect`, `SqlRenderer` and `AnalyticsSource` contracts; `postgresDialect`,
+`Dialect`, `SqlRenderer` and `AnalyticsSource` contracts; `measure.resolved` with the
+`resolvers` option (`MeasureResolver`, `ResolverInput`, `ResolverOutput`); `postgresDialect`,
+`clickhouseDialect` and `toQueryParams`,
 `checkDatasetContract` / `assertDatasetContract`; `measurr/shapes` (`toKpi`, `toTimeseries`,
 `toDistribution`, `toPivot`, `toLeaderboard`) and `measurr/handler` (`queryBatch`,
 `streamBatch`, `toHttpError`); and the types `AnalyticsQuery`, `AnalyticsResult`,
 `ResultPeriod`, `PeriodInput`, `Tenant`, `TenantId`, `AccessKey`, `AnalyticsCache`, `FieldKey`,
 `Ratio`, `AnalyticsError` codes and their details (`isAnalyticsError`). `ExprNode` and
-`SelectStatement` are exported for dialect authors and may grow new node kinds.
+`SelectStatement` are exported for dialect authors and may grow new node kinds. The
+presenters and wire outputs in `measurr/shapes`, `measurr/metrics` and `analytics.timezone`
+are new and may still change before they join this list.
 
 ## Install
 
@@ -533,13 +700,14 @@ npm install measurr zod
 bun install
 bun run lint   # types and Biome
 bun test
-# With a throwaway Postgres (the integration test creates and drops its own tables):
-ANALYTICS_TEST_DATABASE_URL=postgres://... bun test
+# With a throwaway Postgres and ClickHouse (the integration tests create and drop their own tables):
+ANALYTICS_TEST_DATABASE_URL=postgres://... ANALYTICS_TEST_CLICKHOUSE_URL=http://user:password@localhost:8123 bun test
 bun run build && bun run verify:package
 ```
 
 The integration test reads `ANALYTICS_TEST_DATABASE_URL`, not `DATABASE_URL`, because Bun
-loads `.env` files and that name may point at a real database. CI runs it against Postgres 17.
+loads `.env` files and that name may point at a real database. CI runs them against Postgres 17
+and ClickHouse 24.
 
 Releases are automated with Release Please; see [docs/releasing.md](docs/releasing.md).
 

package/dist/analytics.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 import type { CompiledStatement, Dialect } from './compile.js';
-import type { AnyDataset, AnyDimension, Dataset } from './dataset.js';
-import { type Tenant } from './plan.js';
-import { type DatasetQuery, type QueryResult, type ResultOf } from './query.js';
+import type { AnyDataset, AnyDimension, Dataset, DimensionValue, MeasureValue, ResolvedMeasure } from './dataset.js';
+import { type NormalizedFilter, type Tenant } from './plan.js';
+import { type DatasetQuery, type QueryResult, type ResultOf, type ResultPeriod } from './query.js';
 export type Row = Record<string, unknown>;
 /** A database: a dialect to compile with and a function that runs the compiled SQL. */
 export type AnalyticsSource = {
@@ -59,6 +59,51 @@ export type AnalyticsQueryEvent = {
 export type FieldKey<D> = D extends Dataset<string, infer M, infer Dm> ? keyof (M & Dm) & string : never;
 /** The access keys a dataset's measures and dimensions are marked with. */
 export type AccessKey<D> = D extends Dataset<string, infer M, infer Dm> ? NonNullable<(M & Dm)[keyof (M & Dm)]['access']> : never;
+/** The resolved measures of a dataset. */
+export type ResolvedKey<D> = D extends Dataset<string, infer M> ? {
+    [K in keyof M & string]: M[K] extends {
+        kind: 'resolved';
+    } ? K : never;
+}[keyof M & string] : never;
+/** The values of the measures resolved measure `K` uses. */
+type UsedValues<D, K> = D extends Dataset<string, infer M> ? M[K & keyof M] extends ResolvedMeasure<MeasureResult, infer U> ? {
+    [Used in U & keyof M]: MeasureValue<M[Used]>;
+} : never : never;
+type MeasureResult = ResolvedMeasure['result'];
+/** What a resolver gets for one period of one query. */
+export type ResolverInput<D, K, Ctx> = D extends Dataset<string, infer _M, infer Dm> ? {
+    /**
+     * The result rows in order: their grouped dimensions and the measures `K` uses. One
+     * row when the query has no `groupBy`.
+     */
+    rows: readonly {
+        dimensions: {
+            [G in keyof Dm]?: DimensionValue<Dm[G]>;
+        };
+        values: UsedValues<D, K>;
+    }[];
+    /** The used measures over every row of the period, ungrouped. */
+    totals: UsedValues<D, K>;
+    groupBy: readonly (keyof Dm & string)[];
+    /** The query's filters, open-dimension labels already resolved to keys. */
+    filters: readonly NormalizedFilter[];
+    /** The period being resolved: the query's, or its previous one. */
+    period: ResultPeriod;
+    tenant: Tenant;
+    ctx: Ctx;
+} : never;
+/** One value per row, in the same order, and one for the totals. */
+export type ResolverOutput = {
+    rows: readonly (number | null)[];
+    totals: number | null;
+};
+export type MeasureResolver<D, K, Ctx> = (input: ResolverInput<D, K, Ctx>) => ResolverOutput | Promise<ResolverOutput>;
+/** The code for every resolved measure, by dataset and measure. */
+export type AnalyticsResolvers<DS extends readonly AnyDataset[], Ctx> = {
+    [D in DS[number] as [ResolvedKey<D>] extends [never] ? never : D['key']]: {
+        [K in ResolvedKey<D>]: MeasureResolver<D, K, Ctx>;
+    };
+};
 export type AnalyticsOptions<DS extends readonly AnyDataset[], Ctx> = {
     datasets: DS;
     /** Databases by name; a dataset's `source` picks one, or the only one is used. */
@@ -97,6 +142,13 @@ export type AnalyticsOptions<DS extends readonly AnyDataset[], Ctx> = {
      * swallowed: a failing cache is a miss, never a failed query.
      */
     cache?: AnalyticsCache<Ctx, DS[number]['key']> | undefined;
+    /**
+     * The code for `measure.resolved` measures, by dataset and measure key: called once per
+     * period with the result rows and the values of the measures each one uses. Required for
+     * every resolved measure (`createAnalytics` throws otherwise). What it throws fails the
+     * query; a value that is not a finite number counts as null.
+     */
+    resolvers?: NoInfer<AnalyticsResolvers<DS, Ctx>> | undefined;
 };
 /**
  * A store for finished results, such as Redis. Keys name the dataset and hash everything that
@@ -174,9 +226,15 @@ export type Analytics<DS extends readonly AnyDataset[], Ctx> = {
     }): Promise<z.ZodType<DatasetQuery<DS[number]>>>;
     /** The result schema for one dataset. */
     resultSchema(dataset: DS[number]['key']): z.ZodType<QueryResult<Row, Row>>;
+    /**
+     * The timezone `ctx`'s periods and buckets resolve in: the `timezone` hook's answer, UTC
+     * when it has none. Rejects with `invalid_timezone` for a name the runtime does not know.
+     */
+    timezone(ctx: Ctx): Promise<string>;
     /** The datasets `ctx` may query, with the measures and dimensions it may use. */
     listDatasets(ctx: Ctx): Promise<DatasetCatalogEntry<DS[number]['key']>[]>;
 };
 export type AnalyticsQuery<A> = A extends Analytics<infer DS, never> ? DatasetQuery<DS[number]> : never;
 export type AnalyticsResult<A, Q> = A extends Analytics<infer DS, never> ? ResultOf<DS[number], Q> : never;
 export declare function createAnalytics<const DS extends readonly AnyDataset[], Ctx>(options: AnalyticsOptions<DS, Ctx>): Analytics<DS, Ctx>;
+export {};

package/dist/dataset.d.ts

@@ -53,7 +53,21 @@ export type RatioMeasure<A extends string = string, B extends string = string> =
     readonly numerator: A;
     readonly denominator: B;
 };
-export type AnyMeasure = AggregateMeasure | ShareMeasure | RatioMeasure;
+/**
+ * A value the app computes after the query runs, from the measures it `uses` in each row and
+ * from anything else it can reach (another database, a forecast). The `resolvers` option of
+ * `createAnalytics` supplies the code.
+ */
+export type ResolvedMeasure<R extends MeasureResult = MeasureResult, U extends string = string> = {
+    readonly kind: 'resolved';
+    readonly result: R;
+    readonly label: string;
+    readonly description: string | undefined;
+    /** A resolved measure also needs the access of the measures it uses. */
+    readonly access: string | undefined;
+    readonly uses: readonly U[];
+};
+export type AnyMeasure = AggregateMeasure | ShareMeasure | RatioMeasure | ResolvedMeasure;
 /** The TypeScript type of a measure's value in a result row. */
 export type MeasureValue<M> = M extends {
     result: 'count';
@@ -86,7 +100,23 @@ export declare const measure: {
      * measures of the same dataset; `defineDataset` checks them.
      */
     ratio<const A extends string, const B extends string, Access extends string = never>(numerator: A, denominator: B, options: Described<Access>): RatioMeasure<A, B> & Marked<NoInfer<Access>>;
+    resolved: typeof resolved;
 };
+/**
+ * A value the app computes after the query runs, for numbers one statement cannot give:
+ * another database, a forecast, a per-day average. `uses` names the measures of this dataset
+ * the resolver reads from each row; they are fetched even when the query does not ask for
+ * them. The code goes in `createAnalytics({ resolvers })`. Queries cannot sort by it, since
+ * the database limits the rows before the value exists.
+ */
+declare function resolved<R extends MeasureResult, Access extends string = never>(options: Described<Access> & {
+    result: R;
+    uses?: undefined;
+}): ResolvedMeasure<R, never> & Marked<NoInfer<Access>>;
+declare function resolved<R extends MeasureResult, const U extends string, Access extends string = never>(options: Described<Access> & {
+    result: R;
+    uses: readonly U[];
+}): ResolvedMeasure<R, U> & Marked<NoInfer<Access>>;
 /**
  * How a dimension filters:
  * - `closed`: a fixed set of keys (enum, computed) - `in`, `notIn`, `isEmpty`, `isNotEmpty`;
@@ -274,13 +304,26 @@ export type Dataset<K extends string = string, M extends Record<string, AnyMeasu
     readonly dimensions: Dm;
 };
 export type AnyDataset = Dataset<string, any, any, string>;
-/** Ratio measures may only name other measures of the same dataset. */
+/** Measures the database computes: everything but resolved measures. */
+export type SqlMeasureKey<M> = {
+    [Key in keyof M & string]: M[Key] extends {
+        kind: 'resolved';
+    } ? never : Key;
+}[keyof M & string];
+/**
+ * Ratio measures may only name other SQL measures of the same dataset, and resolved measures
+ * may only use SQL measures.
+ */
 type CheckMeasures<M> = {
     [Key in keyof M]: M[Key] extends {
         kind: 'ratio';
     } ? {
-        numerator: Exclude<keyof M & string, Key>;
-        denominator: Exclude<keyof M & string, Key>;
+        numerator: Exclude<SqlMeasureKey<M>, Key>;
+        denominator: Exclude<SqlMeasureKey<M>, Key>;
+    } : M[Key] extends {
+        kind: 'resolved';
+    } ? {
+        uses: readonly SqlMeasureKey<M>[];
     } : unknown;
 };
 /** Time dimensions may only name declared time fields. */

package/dist/dialects/clickhouse.d.ts

@@ -0,0 +1,26 @@
+import { type CompiledStatement, type Dialect } from '../compile.js';
+/**
+ * ClickHouse: typed `{pN:Type}` parameters (pass them with `toQueryParams`), backquoted
+ * identifiers, `-If` and `-OrNull` aggregates, and buckets in the tenant's timezone. Time
+ * columns are `DateTime` or `DateTime64`, which hold an instant, so no timestamp option is
+ * needed.
+ *
+ * Correlated subqueries are not supported, so `exists` and filters on many-to-many dimensions
+ * (mark them `groupOnly`) fail when `createAnalytics` compiles the dataset.
+ */
+export declare function clickhouseDialect(): Dialect;
+/**
+ * The compiled values as the `query_params` the ClickHouse client takes: `{ p1, p2, ... }`.
+ *
+ * ```ts
+ * execute: async (statement) => {
+ *   const result = await clickhouse.query({
+ *     query: statement.text,
+ *     query_params: toQueryParams(statement),
+ *     format: 'JSONEachRow'
+ *   })
+ *   return result.json()
+ * }
+ * ```
+ */
+export declare function toQueryParams(statement: CompiledStatement): Record<string, unknown>;

package/dist/dialects/clickhouse.js

@@ -0,0 +1,101 @@
+import {
+  CompileError2,
+  decodeNumber2,
+  renderStatement2
+} from "../index-nrjdssft.js";
+import {
+  walk
+} from "../index-e6k30sfp.js";
+
+// src/dialects/clickhouse.ts
+var SETTINGS = "SETTINGS join_use_nulls = 1, enable_positional_arguments = 1";
+function clickhouseDialect() {
+  const zone = (expr, timezone) => `toTimeZone(${expr}, '${timezone.replaceAll("'", "\\'")}')`;
+  const renderer = {
+    name: "clickhouse",
+    quote: (identifier) => `\`${identifier.replaceAll("\\", "\\\\").replaceAll("`", "\\`")}\``,
+    param(value, index) {
+      const { type, bound } = typedParam(value);
+      return { placeholder: `{p${index}:${type}}`, value: bound };
+    },
+    aggregate(fn, arg, where) {
+      switch (fn) {
+        case "count":
+          return where ? `countIf(${where})` : "count()";
+        case "countDistinct":
+          return where ? `uniqExactIf(${arg}, ${where})` : `uniqExact(${arg})`;
+        case "sum":
+        case "avg": {
+          const args = where ? `${arg}, ${where}` : arg;
+          return `${fn}${where ? "If" : ""}OrNull(${args})`;
+        }
+        case "median":
+          return where ? `quantileExactInclusiveIfOrNull(0.5)(${arg}, ${where})` : `quantileExactInclusiveOrNull(0.5)(${arg})`;
+      }
+    },
+    divide: (left, right) => `(toFloat64(${left}) / nullIf(${right}, 0))`,
+    toText: (expr) => `toString(${expr})`,
+    timeBucket(unit, expr, timezone) {
+      const local = zone(expr, timezone);
+      switch (unit) {
+        case "day":
+          return `toString(toDate(${local}))`;
+        case "week":
+          return `toString(toMonday(${local}))`;
+        case "month":
+          return `toString(toStartOfMonth(${local}))`;
+      }
+    },
+    timePart: (part, expr, timezone) => part === "isodow" ? `toDayOfWeek(${zone(expr, timezone)})` : `toHour(${zone(expr, timezone)})`
+  };
+  return {
+    name: "clickhouse",
+    compile(statement) {
+      rejectCorrelatedSubqueries(statement);
+      const compiled = renderStatement2(statement, renderer);
+      return { ...compiled, text: `${compiled.text}
+${SETTINGS}` };
+    },
+    decodeNumber: decodeNumber2
+  };
+}
+function toQueryParams(statement) {
+  return Object.fromEntries(statement.values.map((value, index) => [`p${index + 1}`, value]));
+}
+function typedParam(value) {
+  if (value === null)
+    return { type: "Nullable(String)", bound: null };
+  if (value instanceof Date) {
+    const utc = value.toISOString().replace("T", " ").replace("Z", "");
+    return { type: "DateTime64(3, 'UTC')", bound: utc };
+  }
+  switch (typeof value) {
+    case "string":
+      return { type: "String", bound: value };
+    case "boolean":
+      return { type: "Bool", bound: value };
+    case "number":
+      return {
+        type: Number.isSafeInteger(value) ? "Int64" : "Float64",
+        bound: value
+      };
+  }
+}
+function rejectCorrelatedSubqueries(statement) {
+  const nodes = [
+    ...statement.select.map((item) => item.node),
+    ...statement.where,
+    ...statement.virtualJoins.map((join) => join.on)
+  ];
+  for (const node of nodes) {
+    walk(node, (inner) => {
+      if (inner.kind === "exists") {
+        throw new CompileError2(`ClickHouse cannot run the correlated EXISTS that ${inner.table.name} needs: avoid exists() and mark many-to-many dimensions groupOnly`);
+      }
+    });
+  }
+}
+export {
+  clickhouseDialect,
+  toQueryParams
+};

package/dist/handler.js

@@ -1,49 +1,11 @@
 import {
-  AnalyticsError2
-} from "./index-zgb1e89d.js";
-
-// src/handler.ts
-async function queryBatch(analytics, queries, ctx) {
-  const results = {};
-  const errors = {};
-  for await (const chunk of streamBatch(analytics, queries, ctx)) {
-    if ("error" in chunk)
-      errors[chunk.key] = chunk.error;
-    else
-      results[chunk.key] = chunk.result;
-  }
-  return { results, errors };
-}
-async function* streamBatch(analytics, queries, ctx) {
-  const pending = new Map(Object.entries(queries).map(([key, query]) => {
-    const settled = analytics.query(query, ctx).then((result) => ({ key, result }), (error) => ({ key, error: batchError(error) }));
-    return [key, settled];
-  }));
-  while (pending.size > 0) {
-    const chunk = await Promise.race(pending.values());
-    pending.delete(chunk.key);
-    yield chunk;
-  }
-}
-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 }
-  };
-}
+  queryBatch2,
+  streamBatch2,
+  toHttpError2
+} from "./index-psw9s799.js";
+import"./index-g0ah4ehn.js";
 export {
-  queryBatch,
-  streamBatch,
-  toHttpError
+  queryBatch2 as queryBatch,
+  streamBatch2 as streamBatch,
+  toHttpError2 as toHttpError
 };

package/dist/{index-g255jb1s.js → index-115syy01.js}

@@ -146,4 +146,4 @@ function bucketStarts(from, to, unit) {
   return starts;
 }
 
-export { MAX_PERIOD_DAYS, DEFAULT_PERIOD, isValidTimezone, PeriodError, resolvePeriod, previousPeriod, bucketStarts };
+export { MAX_PERIOD_DAYS, DEFAULT_PERIOD, isValidTimezone, localDate, PeriodError, resolvePeriod, previousPeriod, bucketStarts };