measurr 0.1.0 → 0.3.0

package/dist/query.d.ts

@@ -80,14 +80,30 @@ export type ResultRow<M, Dm, MeasureKey extends string, GroupKey extends string>
 export type ResultTotals<M, MeasureKey extends string> = Simplify<{
     [Key in MeasureKey & keyof M]: MeasureValue<M[Key]>;
 }>;
-export type QueryResult<Row, Totals> = {
-    period: {
-        from: string;
-        to: string;
-        timezone: string;
-    };
+/** The days a result covers: local days `from` to `to` (inclusive), or all time. */
+export type ResultPeriod = {
+    from: string;
+    to: string;
+    timezone: string;
+} | {
+    all: true;
+    timezone: string;
+};
+/** The period query `Q` names; null or none means the dataset's `Default`. */
+type QueryPeriod<Q, Default> = Q extends unknown ? 'period' extends keyof Q ? OrDefault<Q['period' & keyof Q], Default> : Default : never;
+type OrDefault<P, Default> = P extends null | undefined ? Default : P;
+type PeriodShape<P> = P extends {
+    all: true;
+} ? Extract<ResultPeriod, {
+    all: true;
+}> : Exclude<ResultPeriod, {
+    all: true;
+}>;
+export type QueryResult<Row, Totals, Period extends ResultPeriod = ResultPeriod> = {
+    period: Period;
     rows: Row[];
     totals: Totals;
+    /** Only for a range: an all-time period has no previous period. */
     previous?: {
         period: {
             from: string;
@@ -101,28 +117,10 @@ export type QueryResult<Row, Totals> = {
     truncated: boolean;
 };
 /** The typed result of query `Q` against the datasets `DS`. */
-export type ResultOf<DS, Q> = DS extends Dataset<infer K, infer M, infer Dm, string> ? Q extends {
+export type ResultOf<DS, Q> = DS extends Dataset<infer K, infer M, infer Dm, string, infer P> ? Q extends {
     dataset: K;
     measures: readonly (infer Mk extends string)[];
-} ? QueryResult<ResultRow<M, Dm, Mk, GroupKeys<Q>>, ResultTotals<M, Mk>> : never : never;
-export declare const periodSchema: z.ZodUnion<readonly [z.ZodObject<{
-    last: z.ZodObject<{
-        days: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    from: z.ZodISODate;
-    to: z.ZodISODate;
-}, z.core.$strip>, z.ZodObject<{
-    preset: z.ZodEnum<{
-        lastMonth: "lastMonth";
-        lastWeek: "lastWeek";
-        thisMonth: "thisMonth";
-        thisWeek: "thisWeek";
-        thisYear: "thisYear";
-        today: "today";
-        yesterday: "yesterday";
-    }>;
-}, z.core.$strip>]>;
+} ? QueryResult<ResultRow<M, Dm, Mk, GroupKeys<Q>>, ResultTotals<M, Mk>, PeriodShape<QueryPeriod<Q, P>>> : never : never;
 /** The input schema branch for one dataset. */
 export declare function datasetQuerySchema(dataset: AnyDataset): z.ZodObject<{
     dataset: z.ZodLiteral<string>;
@@ -250,6 +248,8 @@ export declare function datasetQuerySchema(dataset: AnyDataset): z.ZodObject<{
             today: "today";
             yesterday: "yesterday";
         }>;
+    }, z.core.$strip>, z.ZodObject<{
+        all: z.ZodLiteral<true>;
     }, z.core.$strip>]>>>;
     time?: z.ZodOptional<z.ZodEnum<{
         [x: string]: string;
@@ -393,6 +393,8 @@ export declare function buildQuerySchema(datasets: readonly AnyDataset[]): z.Zod
             today: "today";
             yesterday: "yesterday";
         }>;
+    }, z.core.$strip>, z.ZodObject<{
+        all: z.ZodLiteral<true>;
     }, z.core.$strip>]>>>;
     time?: z.ZodOptional<z.ZodEnum<{
         [x: string]: string;
@@ -534,6 +536,8 @@ export declare function buildQuerySchema(datasets: readonly AnyDataset[]): z.Zod
             today: "today";
             yesterday: "yesterday";
         }>;
+    }, z.core.$strip>, z.ZodObject<{
+        all: z.ZodLiteral<true>;
     }, z.core.$strip>]>>>;
     time?: z.ZodOptional<z.ZodEnum<{
         [x: string]: string;
@@ -552,11 +556,14 @@ export declare function buildQuerySchema(datasets: readonly AnyDataset[]): z.Zod
 }, z.core.$strip>[]], "dataset">;
 /** The result schema for one dataset. Row fields exist only for grouped dimensions. */
 export declare function datasetResultSchema(dataset: AnyDataset): z.ZodObject<{
-    period: z.ZodObject<{
+    period: z.ZodUnion<readonly [z.ZodObject<{
         from: z.ZodString;
         to: z.ZodString;
         timezone: z.ZodString;
-    }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        all: z.ZodLiteral<true>;
+        timezone: z.ZodString;
+    }, z.core.$strip>]>;
     rows: z.ZodArray<z.ZodObject<{
         [x: string]: z.ZodOptional<z.ZodNullable<z.ZodNumber>> | z.ZodOptional<z.ZodObject<{
             key: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
@@ -591,11 +598,14 @@ export declare function datasetResultSchema(dataset: AnyDataset): z.ZodObject<{
  * For contracts that must not depend on the dataset list, such as an LLM tool's output.
  */
 export declare const AnalyticsResultSchema: z.ZodObject<{
-    period: z.ZodObject<{
+    period: z.ZodUnion<readonly [z.ZodObject<{
         from: z.ZodString;
         to: z.ZodString;
         timezone: z.ZodString;
-    }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        all: z.ZodLiteral<true>;
+        timezone: z.ZodString;
+    }, z.core.$strip>]>;
     rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
         key: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
         label: z.ZodString;

package/dist/testing.js

@@ -3,7 +3,7 @@ import {
   createAnalytics2,
   measure2,
   dimension2
-} from "./index-m0czpsyv.js";
+} from "./index-wrr67sxq.js";
 
 // src/testing.ts
 var COUNT = "__contractCount";
@@ -128,26 +128,31 @@ async function checkDatasetContract(options) {
       });
     }
   }
-  await check("tenant isolation", async () => {
-    const measures = Object.keys(probe.measures);
-    const leaked = [];
-    for (let start = 0;start < measures.length; start += MAX_MEASURES) {
-      const batch = measures.slice(start, start + MAX_MEASURES);
-      const other = await run({ measures: batch }, emptyTenant);
-      leaked.push(...Object.entries(other.totals).filter(([, value]) => value !== 0 && value !== null));
-    }
-    if (leaked.length > 0) {
-      return `an empty tenant sees ${leaked.map(([key, value]) => `${key}=${value}`).join(", ")}`;
-    }
-    for (const [key, entry] of dimensions) {
-      if (!entry.groupable)
-        continue;
-      const grouped = await run({ measures: [COUNT], groupBy: [key] }, emptyTenant);
-      if (grouped.rows.length > 0)
-        return `an empty tenant sees ${grouped.rows.length} ${key} groups`;
-    }
-    return;
-  });
+  for (const [name, tenant] of [
+    ["an empty tenant", emptyTenant],
+    ["an empty tenant list", []]
+  ]) {
+    await check(`tenant isolation: ${name}`, async () => {
+      const measures = Object.keys(probe.measures);
+      const leaked = [];
+      for (let start = 0;start < measures.length; start += MAX_MEASURES) {
+        const batch = measures.slice(start, start + MAX_MEASURES);
+        const result = await run({ measures: batch }, tenant);
+        leaked.push(...Object.entries(result.totals).filter(([, value]) => value !== 0 && value !== null));
+      }
+      if (leaked.length > 0) {
+        return `${name} sees ${leaked.map(([key, value]) => `${key}=${value}`).join(", ")}`;
+      }
+      for (const [key, entry] of dimensions) {
+        if (!entry.groupable)
+          continue;
+        const grouped = await run({ measures: [COUNT], groupBy: [key] }, tenant);
+        if (grouped.rows.length > 0)
+          return `${name} sees ${grouped.rows.length} ${key} groups`;
+      }
+      return;
+    });
+  }
   for (const time of Object.keys(dataset.time)) {
     await check(`day buckets of ${time} in ${timezone}`, async () => {
       const days = await run({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "measurr",
-	"version": "0.1.0",
+	"version": "0.3.0",
 	"description": "A small typed semantic layer: datasets of measures and dimensions compiled to one SQL statement per dialect.",
 	"type": "module",
 	"module": "./dist/index.js",

package/src/analytics.ts

@@ -5,6 +5,9 @@ import {
 	type NormalizedQuery,
 	type ParsedQuery,
 	type PlanContext,
+	type Tenant,
+	type TenantId,
+	allTenants,
 	normalizeQuery,
 	planLookup,
 	planQuery,
@@ -112,8 +115,13 @@ 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. */
 	sources: Record<string, AnalyticsSource>
-	/** The tenant every query is scoped to. Queries without one are refused. */
-	tenant: (ctx: Ctx) => string | number | null | undefined
+	/**
+	 * The tenant every query is scoped to, or a list of them (an empty list matches no rows).
+	 * Queries without one (null, undefined, '', a list holding one of those) are refused.
+	 * Return `allTenants` to drop the tenant filter, only for callers allowed to see every
+	 * tenant's rows.
+	 */
+	tenant: (ctx: Ctx) => Tenant | null | undefined
 	/**
 	 * Whether `ctx` may query `dataset`. Everything is allowed when omitted. It decides what
 	 * `listDatasets(ctx)` and `querySchema({ ctx })` offer, and is checked again on every query.
@@ -195,6 +203,18 @@ export type AnalyticsResult<A, Q> =
 
 type ShapedResult = QueryResult<Row, Row>
 
+/** A parsed, authorized query with everything the hooks decide resolved. */
+type Prepared = {
+	dataset: AnyDataset
+	query: NormalizedQuery
+	tenant: Tenant
+	timezone: string
+	/** Null for all time. */
+	period: ResolvedPeriod | null
+	previous: ResolvedPeriod | null
+	now: Date
+}
+
 export function createAnalytics<const DS extends readonly AnyDataset[], Ctx>(
 	options: AnalyticsOptions<DS, Ctx>
 ): Analytics<DS, Ctx> {
@@ -273,7 +293,7 @@ export function createAnalytics<const DS extends readonly AnyDataset[], Ctx>(
 	}
 
 	/** Parse, authorize, and resolve everything that comes from hooks. */
-	const prepare = async (input: unknown, ctx: Ctx) => {
+	const prepare = async (input: unknown, ctx: Ctx): Promise<Prepared> => {
 		const parsed = querySchemaFor(undefined).safeParse(input)
 		if (!parsed.success) {
 			throw new AnalyticsError(
@@ -291,8 +311,8 @@ export function createAnalytics<const DS extends readonly AnyDataset[], Ctx>(
 			)
 		}
 
-		const tenant = options.tenant(ctx)
-		if (tenant === null || tenant === undefined || tenant === '') {
+		const tenant: unknown = options.tenant(ctx)
+		if (!isTenant(tenant)) {
 			throw new AnalyticsError(
 				'missing_tenant',
 				'Refusing to query without a tenant'
@@ -309,16 +329,19 @@ export function createAnalytics<const DS extends readonly AnyDataset[], Ctx>(
 
 		const query = normalizeQuery(dataset, parsed.data as ParsedQuery)
 		const at = now()
-		let period: ResolvedPeriod
+		let period: ResolvedPeriod | null
 		try {
-			period = resolvePeriod(query.period, timezone, at)
+			period =
+				'all' in query.period ? null : resolvePeriod(query.period, timezone, at)
 		} catch (error) {
 			if (error instanceof PeriodError) {
 				throw new AnalyticsError('invalid_period', error.message)
 			}
 			throw error
 		}
-		const previous = query.compareToPrevious ? previousPeriod(period) : null
+		// The schema refuses compareToPrevious with an all-time period.
+		const previous =
+			query.compareToPrevious && period ? previousPeriod(period) : null
 
 		return { dataset, query, tenant, timezone, period, previous, now: at }
 	}
@@ -340,7 +363,7 @@ export function createAnalytics<const DS extends readonly AnyDataset[], Ctx>(
 			dialect
 		)
 
-		const runPeriod = async (target: ResolvedPeriod) => {
+		const runPeriod = async (target: ResolvedPeriod | null) => {
 			const statements = periodStatements(dataset, query, {
 				tenant,
 				timezone,
@@ -356,27 +379,26 @@ export function createAnalytics<const DS extends readonly AnyDataset[], Ctx>(
 			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 }
+			return { rows, totals, truncated }
 		}
 
+		const range = ({ from, to }: ResolvedPeriod) => ({ from, to, timezone })
 		const [current, before] = await Promise.all([
 			runPeriod(period),
-			previous ? runPeriod(previous) : null
+			previous &&
+				runPeriod(previous).then(({ rows, totals }) => ({
+					period: range(previous),
+					rows,
+					totals
+				}))
 		])
 
 		return {
-			period: current.period,
+			period: period ? range(period) : { all: true, timezone },
 			rows: current.rows,
 			totals: current.totals,
-			...(before && {
-				previous: {
-					period: before.period,
-					rows: before.rows,
-					totals: before.totals
-				}
-			}),
+			...(before && { previous: before }),
 			notes: resultNotes(dataset, query),
 			truncated: current.truncated
 		}
@@ -469,6 +491,26 @@ export function createAnalytics<const DS extends readonly AnyDataset[], Ctx>(
 	}
 }
 
+/**
+ * Fails closed: only a non-empty string, a finite number, a list of those or `allTenants`
+ * scopes a query, even when a JavaScript caller's hook returns something its type does not
+ * allow.
+ */
+function isTenant(value: unknown): value is Tenant {
+	return (
+		value === allTenants ||
+		isTenantId(value) ||
+		(Array.isArray(value) && value.every(isTenantId))
+	)
+}
+
+function isTenantId(value: unknown): value is TenantId {
+	return (
+		(typeof value === 'string' && value !== '') ||
+		(typeof value === 'number' && Number.isFinite(value))
+	)
+}
+
 /** The statement for a period's rows, and for its totals when the query groups. */
 function periodStatements(
 	dataset: AnyDataset,
@@ -562,7 +604,7 @@ function compileEverything(dataset: AnyDataset, dialect: Dialect): void {
 async function resolveOpenValues(
 	dataset: AnyDataset,
 	query: NormalizedQuery,
-	tenant: string | number,
+	tenant: Tenant,
 	now: Date,
 	run: (statement: SelectStatement) => Promise<readonly Row[]>,
 	dialect: Dialect

package/src/dataset.ts

@@ -9,6 +9,7 @@ import {
 	directChildren,
 	rootOf
 } from './expr.js'
+import { DEFAULT_PERIOD, type PeriodInput } from './period.js'
 
 declare const ratioBrand: unique symbol
 
@@ -532,7 +533,8 @@ export type Dataset<
 	K extends string = string,
 	M extends Record<string, AnyMeasure> = Record<string, AnyMeasure>,
 	Dm extends Record<string, AnyDimension> = Record<string, AnyDimension>,
-	T extends string = string
+	T extends string = string,
+	P extends PeriodInput = PeriodInput
 > = {
 	readonly key: K
 	readonly label: string
@@ -543,6 +545,8 @@ export type Dataset<
 	readonly scope: ExprNode | null
 	readonly time: Readonly<Record<T, TimeField>>
 	readonly defaultTime: T
+	/** Kept as a type, so results know whether a query without a period covers all time. */
+	readonly defaultPeriod: P
 	readonly measures: M
 	readonly dimensions: Dm
 }
@@ -571,7 +575,8 @@ export type DatasetDefinition<
 	K extends string,
 	M extends Record<string, AnyMeasure>,
 	Dm extends Record<string, AnyDimension>,
-	T extends string
+	T extends string,
+	P extends PeriodInput
 > = {
 	key: K
 	label: string
@@ -587,6 +592,11 @@ export type DatasetDefinition<
 	time: Record<T, { column: Expr<'timestamp'>; label: string }>
 	/** The time field periods apply to when a query names none; the first one by default. */
 	defaultTime?: NoInfer<T> | undefined
+	/**
+	 * The period of a query that names none; the last 30 days by default. A dataset of current
+	 * state (units, organizations) sets `{ all: true }`.
+	 */
+	defaultPeriod?: P | undefined
 	measures: M & CheckMeasures<M>
 	dimensions: Dm & CheckDimensions<Dm, NoInfer<T>>
 }
@@ -599,8 +609,9 @@ export function defineDataset<
 	const K extends string,
 	const M extends Record<string, AnyMeasure>,
 	const Dm extends Record<string, AnyDimension>,
-	const T extends string
->(definition: DatasetDefinition<K, M, Dm, T>): Dataset<K, M, Dm, T> {
+	const T extends string,
+	const P extends PeriodInput = typeof DEFAULT_PERIOD
+>(definition: DatasetDefinition<K, M, Dm, T, P>): Dataset<K, M, Dm, T, P> {
 	const timeEntries = Object.entries<{
 		column: Expr<'timestamp'>
 		label: string
@@ -619,7 +630,7 @@ export function defineDataset<
 		])
 	) as Record<T, TimeField>
 
-	const dataset: Dataset<K, M, Dm, T> = {
+	const dataset: Dataset<K, M, Dm, T, P> = {
 		key: definition.key,
 		label: definition.label,
 		description: definition.description,
@@ -629,6 +640,8 @@ export function defineDataset<
 		scope: definition.scope?.node ?? null,
 		time,
 		defaultTime: definition.defaultTime ?? (firstTime[0] as T),
+		// P is DEFAULT_PERIOD's type when the definition names no period.
+		defaultPeriod: definition.defaultPeriod ?? (DEFAULT_PERIOD as P),
 		measures: definition.measures,
 		dimensions: definition.dimensions
 	}

package/src/guidance.ts

@@ -4,7 +4,7 @@
  */
 export const analyticsToolGuidance = `- Answer every "how many", "how much", "per week" or "split by" question with the analytics tool. Never count by hand from lists or pages.
 - Pick the dataset whose description matches the question, the fewest measures that answer it and at most two groupings.
-- Say which period and filters the numbers cover, using the dates in the result ("1-30 September").
+- Say which period and filters the numbers cover, using the dates in the result ("1-30 September", or "all time").
 - Compare with the previous period (compareToPrevious) when the change is the point, such as "is it going up".
 - When the result has notes (overlapping rows, such as a record counted once per tag), say so in a few words.
 - Ask one short question only when the period is genuinely ambiguous ("this season") and someone can answer; otherwise take the natural reading and state it.`

package/src/index.ts

@@ -65,10 +65,12 @@ export {
 } from './expr.js'
 export { analyticsToolGuidance } from './guidance.js'
 export type { PeriodInput, PeriodPreset } from './period.js'
+export { allTenants, type Tenant, type TenantId } from './plan.js'
 export {
 	AnalyticsResultSchema,
 	type DatasetFilter,
 	type DatasetQuery,
 	type QueryResult,
-	type ResultOf
+	type ResultOf,
+	type ResultPeriod
 } from './query.js'

package/src/period.ts

@@ -13,11 +13,15 @@ export type PeriodPreset =
 	| 'lastMonth'
 	| 'thisYear'
 
-export type PeriodInput =
+/** A range of days: what `resolvePeriod` turns into instants. */
+export type PeriodRange =
 	| { last: { days: number } }
 	| { from: string; to: string }
 	| { preset: PeriodPreset }
 
+/** A range of days, or `{ all: true }` for no time filter. */
+export type PeriodInput = PeriodRange | { all: true }
+
 export type ResolvedPeriod = {
 	/** First local day, `YYYY-MM-DD`. */
 	from: string
@@ -32,7 +36,9 @@ export type ResolvedPeriod = {
 }
 
 export const MAX_PERIOD_DAYS = 731
-export const DEFAULT_PERIOD: PeriodInput = { last: { days: 30 } }
+export const DEFAULT_PERIOD = {
+	last: { days: 30 }
+} as const satisfies PeriodInput
 
 const DAY_MS = 86_400_000
 
@@ -140,7 +146,7 @@ export class PeriodError extends Error {
 
 /** Resolves a period input to local days and instants in `timezone`. */
 export function resolvePeriod(
-	input: PeriodInput,
+	input: PeriodRange,
 	timezone: string,
 	now: Date
 ): ResolvedPeriod {
@@ -154,7 +160,7 @@ export function resolvePeriod(
 	return periodFromDays(from, to, timezone)
 }
 
-function periodDays(input: PeriodInput, today: string): [string, string] {
+function periodDays(input: PeriodRange, today: string): [string, string] {
 	if ('last' in input) return [addDays(today, -(input.last.days - 1)), today]
 	if ('from' in input) return [input.from, input.to]
 

package/src/plan.ts

@@ -6,11 +6,7 @@ import type {
 } from './compile.js'
 import type { AnyDataset, AnyDimension, AnyMeasure } from './dataset.js'
 import type { ExprNode, ParamValue } from './expr.js'
-import {
-	DEFAULT_PERIOD,
-	type PeriodInput,
-	type ResolvedPeriod
-} from './period.js'
+import type { PeriodInput, ResolvedPeriod } from './period.js'
 import { DEFAULT_LIMIT } from './query.js'
 
 /** A parsed query with every default filled in and duplicates removed. */
@@ -65,7 +61,7 @@ export function normalizeQuery(
 		// Order matters: the first grouped dimension leads the rows.
 		groupBy: [...new Set(parsed.groupBy ?? [])],
 		filters,
-		period: parsed.period ?? DEFAULT_PERIOD,
+		period: parsed.period ?? dataset.defaultPeriod,
 		time: parsed.time ?? dataset.defaultTime,
 		compareToPrevious: parsed.compareToPrevious ?? false,
 		sort: parsed.sort
@@ -75,11 +71,23 @@ export function normalizeQuery(
 	}
 }
 
+/**
+ * What `tenant(ctx)` returns to query every tenant at once, for platform admins. It is a
+ * symbol, so no query input (JSON, a model's tool call) can ever carry it.
+ */
+export const allTenants: unique symbol = Symbol('measurr.allTenants')
+
+export type TenantId = string | number
+
+/** One tenant's id, a list of them (an empty list matches no rows), or `allTenants`. */
+export type Tenant = TenantId | readonly TenantId[] | typeof allTenants
+
 /** What the planner needs besides the query: values from the hooks and resolved labels. */
 export type PlanContext = {
-	tenant: string | number
+	tenant: Tenant
 	timezone: string
-	period: ResolvedPeriod
+	/** Null for an all-time period: no time filter. */
+	period: ResolvedPeriod | null
 	/** The moment the query runs. */
 	now: Date
 	/** Keys for filters on open dimensions, after label resolution, by dimension. */
@@ -203,17 +211,30 @@ function dimensionNodes(
 /** Tenant, scope and period: the conditions every statement of a query carries. */
 function baseWhere(
 	dataset: AnyDataset,
-	tenant: string | number,
+	tenant: Tenant,
 	period: { time: string; start: Date; end: Date } | null
 ): ExprNode[] {
-	const where: ExprNode[] = [
-		{
-			kind: 'compare',
-			op: '=',
-			left: dataset.tenantColumn,
-			right: param(tenant)
-		}
-	]
+	const where: ExprNode[] = []
+	if (tenant !== allTenants) {
+		const ids = typeof tenant === 'object' ? [...new Set(tenant)] : [tenant]
+		const [only] = ids
+		// One id compiles exactly like the scalar; an empty list renders as a false condition.
+		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
+					}
+		)
+	}
 	if (dataset.scope) where.push(dataset.scope)
 
 	if (period) {
@@ -345,11 +366,15 @@ export function planQuery(
 	}
 
 	const where = [
-		...baseWhere(dataset, context.tenant, {
-			time: query.time,
-			start: context.period.start,
-			end: context.period.end
-		}),
+		...baseWhere(
+			dataset,
+			context.tenant,
+			context.period && {
+				time: query.time,
+				start: context.period.start,
+				end: context.period.end
+			}
+		),
 		...query.filters.map((filter) => filterNode(dataset, filter, context))
 	]
 
@@ -408,7 +433,7 @@ function orderBy(
 export function planLookup(
 	dataset: AnyDataset,
 	dimensionKey: string,
-	tenant: string | number,
+	tenant: Tenant,
 	values: readonly string[] | null,
 	now: Date
 ): SelectStatement {