@happyvertical/smrt-reports 0.37.2 → 0.37.4

package/dist/refresh.js

@@ -1,428 +1,344 @@
-import { createHash, randomUUID } from "node:crypto";
+import { buildReportDefinition, compileReportDefinition, getReportGroupingColumns } from "./compiler.js";
+import { REPORT_LOCKS_TABLE, REPORT_RUNS_TABLE, REPORT_WATERMARKS_TABLE, assertReportTablesReady, scopeKeyForTenant } from "./state.js";
+import { buildAggregate, buildWhere, tableExists, validateColumnName } from "@happyvertical/sql";
 import { ObjectRegistry } from "@happyvertical/smrt-core";
 import { toSnakeCase } from "@happyvertical/smrt-core/utils";
-import { withTenant, getTenantId } from "@happyvertical/smrt-tenancy";
-import { tableExists, buildAggregate, validateColumnName, buildWhere } from "@happyvertical/sql";
-import { getReportGroupingColumns, buildReportDefinition, compileReportDefinition } from "./compiler.js";
-import { assertReportTablesReady, REPORT_RUNS_TABLE, REPORT_WATERMARKS_TABLE, REPORT_LOCKS_TABLE, scopeKeyForTenant } from "./state.js";
+import { createHash, randomUUID } from "node:crypto";
+import { getTenantId, withTenant } from "@happyvertical/smrt-tenancy";
+//#region src/refresh.ts
 function isSqlAdapterType(value) {
-  return value === "sqlite" || value === "postgres" || value === "duckdb" || value === "json";
+	return value === "sqlite" || value === "postgres" || value === "duckdb" || value === "json";
 }
 function adapterTypeFromDb(db, fallback) {
-  if (isSqlAdapterType(fallback)) return fallback;
-  const url = String(db.url ?? "");
-  if (url.startsWith("postgres://") || url.startsWith("postgresql://")) {
-    return "postgres";
-  }
-  if (url.endsWith(".duckdb")) {
-    return "duckdb";
-  }
-  if (url === ":memory:" || url.endsWith(".sqlite") || url.endsWith(".db")) {
-    return "sqlite";
-  }
-  throw new Error(
-    "Report refresh requires a database adapter type. Pass { adapterType }."
-  );
+	if (isSqlAdapterType(fallback)) return fallback;
+	const url = String(db.url ?? "");
+	if (url.startsWith("postgres://") || url.startsWith("postgresql://")) return "postgres";
+	if (url.endsWith(".duckdb")) return "duckdb";
+	if (url === ":memory:" || url.endsWith(".sqlite") || url.endsWith(".db")) return "sqlite";
+	throw new Error("Report refresh requires a database adapter type. Pass { adapterType }.");
 }
 function stableReportId(values) {
-  const hash = createHash("sha256").update(JSON.stringify(values)).digest("hex");
-  const variant = (Number.parseInt(hash[16], 16) & 3 | 8).toString(16);
-  return [
-    hash.slice(0, 8),
-    hash.slice(8, 12),
-    `4${hash.slice(13, 16)}`,
-    `${variant}${hash.slice(17, 20)}`,
-    hash.slice(20, 32)
-  ].join("-");
+	const hash = createHash("sha256").update(JSON.stringify(values)).digest("hex");
+	const variant = (Number.parseInt(hash[16], 16) & 3 | 8).toString(16);
+	return [
+		hash.slice(0, 8),
+		hash.slice(8, 12),
+		`4${hash.slice(13, 16)}`,
+		`${variant}${hash.slice(17, 20)}`,
+		hash.slice(20, 32)
+	].join("-");
 }
 function getReportTableName(reportCtor) {
-  const registered = ObjectRegistry.getClassByConstructor(reportCtor) ?? ObjectRegistry.getClass(reportCtor.name);
-  const tableName = registered ? ObjectRegistry.getTableName(registered.qualifiedName ?? registered.name) : ObjectRegistry.getTableName(reportCtor.name);
-  if (!tableName) {
-    throw new Error(`No report table registered for ${reportCtor.name}`);
-  }
-  return tableName;
+	const registered = ObjectRegistry.getClassByConstructor(reportCtor) ?? ObjectRegistry.getClass(reportCtor.name);
+	const tableName = registered ? ObjectRegistry.getTableName(registered.qualifiedName ?? registered.name) : ObjectRegistry.getTableName(reportCtor.name);
+	if (!tableName) throw new Error(`No report table registered for ${reportCtor.name}`);
+	return tableName;
 }
 function getActualGroupingColumns(definition) {
-  return definition.fields.filter(
-    (field) => field.report?.kind === "group" || field.report?.kind === "bucket"
-  ).map((field) => field.columnName ?? toSnakeCase(field.fieldName));
+	return definition.fields.filter((field) => field.report?.kind === "group" || field.report?.kind === "bucket").map((field) => field.columnName ?? toSnakeCase(field.fieldName));
 }
 function materializeRows(rows, definition, refreshedAt, scope) {
-  const groupingColumns = getActualGroupingColumns(definition);
-  const now = refreshedAt.toISOString();
-  return rows.map((row, index) => {
-    const groupingValues = groupingColumns.length === 0 ? [definition.reportClassName, scope.scopeKey, index] : [
-      definition.reportClassName,
-      scope.scopeKey,
-      ...groupingColumns.map((column) => row[column])
-    ];
-    const id = stableReportId(groupingValues);
-    const tenantFields = scope.reportTenantColumn ? { [scope.reportTenantColumn]: scope.tenantId } : {};
-    return {
-      id,
-      slug: id,
-      context: scope.scopeKey,
-      ...tenantFields,
-      ...row,
-      refreshed_at: now,
-      created_at: now,
-      updated_at: now
-    };
-  });
+	const groupingColumns = getActualGroupingColumns(definition);
+	const now = refreshedAt.toISOString();
+	return rows.map((row, index) => {
+		const id = stableReportId(groupingColumns.length === 0 ? [
+			definition.reportClassName,
+			scope.scopeKey,
+			index
+		] : [
+			definition.reportClassName,
+			scope.scopeKey,
+			...groupingColumns.map((column) => row[column])
+		]);
+		const tenantFields = scope.reportTenantColumn ? { [scope.reportTenantColumn]: scope.tenantId } : {};
+		return {
+			id,
+			slug: id,
+			context: scope.scopeKey,
+			...tenantFields,
+			...row,
+			refreshed_at: now,
+			created_at: now,
+			updated_at: now
+		};
+	});
 }
 function sourceClassName(source) {
-  if (typeof source === "string") return source;
-  return source.name;
+	if (typeof source === "string") return source;
+	return source.name;
 }
 async function fieldColumn(className, requested) {
-  const fields = await ObjectRegistry.getAllFields(className);
-  const requestedColumn = toSnakeCase(requested);
-  for (const [fieldName] of fields.entries()) {
-    if (fieldName === requested || toSnakeCase(fieldName) === requestedColumn) {
-      return requestedColumn;
-    }
-  }
-  return null;
+	const fields = await ObjectRegistry.getAllFields(className);
+	const requestedColumn = toSnakeCase(requested);
+	for (const [fieldName] of fields.entries()) if (fieldName === requested || toSnakeCase(fieldName) === requestedColumn) return requestedColumn;
+	return null;
 }
 async function tenantColumn(className) {
-  const registered = ObjectRegistry.getClass(className);
-  const configuredField = registered?.tenantScopedConfig?.field;
-  if (configuredField) {
-    return toSnakeCase(configuredField);
-  }
-  const fields = await ObjectRegistry.getAllFields(className);
-  for (const [fieldName, field] of fields.entries()) {
-    if (field?._meta?.__tenancy?.isTenantIdField) {
-      return toSnakeCase(fieldName);
-    }
-  }
-  const tenantIdField = await fieldColumn(className, "tenantId");
-  return tenantIdField;
+	const configuredField = ObjectRegistry.getClass(className)?.tenantScopedConfig?.field;
+	if (configuredField) return toSnakeCase(configuredField);
+	const fields = await ObjectRegistry.getAllFields(className);
+	for (const [fieldName, field] of fields.entries()) if (field?._meta?.__tenancy?.isTenantIdField) return toSnakeCase(fieldName);
+	return await fieldColumn(className, "tenantId");
 }
 async function resolveScope(definition, options) {
-  const tenantId = options.tenantId !== void 0 ? options.tenantId : getTenantId() ?? null;
-  const sourceTenantColumn = await tenantColumn(definition.sourceClassName);
-  const reportTenantColumn = await tenantColumn(definition.reportClassName);
-  if (tenantId && !sourceTenantColumn) {
-    throw new Error(
-      `Tenant-scoped refresh for ${definition.reportClassName} requires source ${definition.sourceClassName} to expose a tenantId field.`
-    );
-  }
-  if (tenantId && !reportTenantColumn) {
-    throw new Error(
-      `Tenant-scoped refresh for ${definition.reportClassName} requires the report table to expose a tenantId field.`
-    );
-  }
-  return {
-    tenantId,
-    scopeKey: scopeKeyForTenant(tenantId),
-    sourceTenantColumn,
-    reportTenantColumn
-  };
+	const tenantId = options.tenantId !== void 0 ? options.tenantId : getTenantId() ?? null;
+	const sourceTenantColumn = await tenantColumn(definition.sourceClassName);
+	const reportTenantColumn = await tenantColumn(definition.reportClassName);
+	if (tenantId && !sourceTenantColumn) throw new Error(`Tenant-scoped refresh for ${definition.reportClassName} requires source ${definition.sourceClassName} to expose a tenantId field.`);
+	if (tenantId && !reportTenantColumn) throw new Error(`Tenant-scoped refresh for ${definition.reportClassName} requires the report table to expose a tenantId field.`);
+	return {
+		tenantId,
+		scopeKey: scopeKeyForTenant(tenantId),
+		sourceTenantColumn,
+		reportTenantColumn
+	};
 }
 function tenantWhere(scope) {
-  if (!scope.sourceTenantColumn) return {};
-  return { [scope.sourceTenantColumn]: scope.tenantId };
+	if (!scope.sourceTenantColumn) return {};
+	return { [scope.sourceTenantColumn]: scope.tenantId };
 }
 function andWhere(base, extra) {
-  if (Object.keys(extra).length === 0) return base;
-  if (!base) return extra;
-  if (Array.isArray(base)) {
-    return base.map((andGroup) => [...andGroup, extra]);
-  }
-  return { ...base, ...extra };
+	if (Object.keys(extra).length === 0) return base;
+	if (!base) return extra;
+	if (Array.isArray(base)) return base.map((andGroup) => [...andGroup, extra]);
+	return {
+		...base,
+		...extra
+	};
 }
 function andHaving(base, extra) {
-  if (Object.keys(extra).length === 0) return base;
-  if (!base) return extra;
-  if (Array.isArray(base)) {
-    return base.map((andGroup) => [...andGroup, extra]);
-  }
-  return { ...base, ...extra };
+	if (Object.keys(extra).length === 0) return base;
+	if (!base) return extra;
+	if (Array.isArray(base)) return base.map((andGroup) => [...andGroup, extra]);
+	return {
+		...base,
+		...extra
+	};
 }
 function withRefreshFilters(spec, scope, extraWhere = {}) {
-  return {
-    ...spec,
-    where: andWhere(spec.where, {
-      ...tenantWhere(scope),
-      ...extraWhere
-    })
-  };
+	return {
+		...spec,
+		where: andWhere(spec.where, {
+			...tenantWhere(scope),
+			...extraWhere
+		})
+	};
 }
 async function resolveWatermarkConfig(definition) {
-  const configured = definition.refresh ?? {};
-  const watermarkField = configured.watermarkColumn ?? "updatedAt";
-  const softDeleteField = configured.softDeleteColumn ?? "deletedAt";
-  const watermarkColumn = await fieldColumn(
-    definition.sourceClassName,
-    watermarkField
-  );
-  const softDeleteColumn = await fieldColumn(
-    definition.sourceClassName,
-    softDeleteField
-  );
-  if (!watermarkColumn) {
-    throw new Error(
-      `Incremental report ${definition.reportClassName} requires source ${definition.sourceClassName} to define watermark column '${watermarkField}'.`
-    );
-  }
-  if (!softDeleteColumn) {
-    throw new Error(
-      `Incremental report ${definition.reportClassName} requires source ${definition.sourceClassName} to define soft-delete column '${softDeleteField}'.`
-    );
-  }
-  return { watermarkColumn, softDeleteColumn };
+	const configured = definition.refresh ?? {};
+	const watermarkField = configured.watermarkColumn ?? "updatedAt";
+	const softDeleteField = configured.softDeleteColumn ?? "deletedAt";
+	const watermarkColumn = await fieldColumn(definition.sourceClassName, watermarkField);
+	const softDeleteColumn = await fieldColumn(definition.sourceClassName, softDeleteField);
+	if (!watermarkColumn) throw new Error(`Incremental report ${definition.reportClassName} requires source ${definition.sourceClassName} to define watermark column '${watermarkField}'.`);
+	if (!softDeleteColumn) throw new Error(`Incremental report ${definition.reportClassName} requires source ${definition.sourceClassName} to define soft-delete column '${softDeleteField}'.`);
+	return {
+		watermarkColumn,
+		softDeleteColumn
+	};
 }
 function compileChangedGroupSpec(definition, scope, watermark, watermarkBefore) {
-  const spec = compileReportDefinition(definition);
-  const select = spec.select.filter(
-    (expr) => !("fn" in expr)
-  );
-  return withRefreshFilters(
-    {
-      ...spec,
-      // Ignore the report filter while finding changed groups so rows that
-      // just stopped matching `report.where` still trigger a recompute/delete.
-      where: void 0,
-      select: select.length > 0 ? select : [{ fn: "count", as: "__smrt_changed_count" }],
-      groupBy: select.length > 0 ? spec.groupBy : [],
-      having: void 0
-    },
-    scope,
-    { [`${watermark.watermarkColumn} >`]: watermarkBefore }
-  );
+	const spec = compileReportDefinition(definition);
+	const select = spec.select.filter((expr) => !("fn" in expr));
+	return withRefreshFilters({
+		...spec,
+		where: void 0,
+		select: select.length > 0 ? select : [{
+			fn: "count",
+			as: "__smrt_changed_count"
+		}],
+		groupBy: select.length > 0 ? spec.groupBy : [],
+		having: void 0
+	}, scope, { [`${watermark.watermarkColumn} >`]: watermarkBefore });
 }
 function compileAffectedGroupSpec(definition, scope, watermark, groupRow) {
-  const groupingColumns = getActualGroupingColumns(definition);
-  const groupHaving = Object.fromEntries(
-    groupingColumns.map((column) => [column, groupRow[column]])
-  );
-  const spec = withRefreshFilters(compileReportDefinition(definition), scope, {
-    [watermark.softDeleteColumn]: null
-  });
-  return {
-    ...spec,
-    having: andHaving(spec.having, groupHaving)
-  };
+	const groupingColumns = getActualGroupingColumns(definition);
+	const groupHaving = Object.fromEntries(groupingColumns.map((column) => [column, groupRow[column]]));
+	const spec = withRefreshFilters(compileReportDefinition(definition), scope, { [watermark.softDeleteColumn]: null });
+	return {
+		...spec,
+		having: andHaving(spec.having, groupHaving)
+	};
 }
 function conflictColumns(definition, scope) {
-  const groupingColumns = getActualGroupingColumns(definition);
-  if (groupingColumns.length === 0) return ["id"];
-  return [
-    ...scope.reportTenantColumn ? [scope.reportTenantColumn] : [],
-    ...groupingColumns
-  ];
+	const groupingColumns = getActualGroupingColumns(definition);
+	if (groupingColumns.length === 0) return ["id"];
+	return [...scope.reportTenantColumn ? [scope.reportTenantColumn] : [], ...groupingColumns];
 }
 function predicateSql(tableName, predicate) {
-  validateColumnName(tableName);
-  const clauses = [];
-  const values = [];
-  for (const [column, value] of Object.entries(predicate)) {
-    validateColumnName(column);
-    if (value === null || value === void 0) {
-      clauses.push(`${column} IS NULL`);
-      continue;
-    }
-    clauses.push(`${column} = ?`);
-    values.push(value);
-  }
-  return {
-    sql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
-    values
-  };
+	validateColumnName(tableName);
+	const clauses = [];
+	const values = [];
+	for (const [column, value] of Object.entries(predicate)) {
+		validateColumnName(column);
+		if (value === null || value === void 0) {
+			clauses.push(`${column} IS NULL`);
+			continue;
+		}
+		clauses.push(`${column} = ?`);
+		values.push(value);
+	}
+	return {
+		sql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
+		values
+	};
 }
 function dedupeGroupRows(definition, rows) {
-  const groupingColumns = getActualGroupingColumns(definition);
-  const groups = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    if (!row) continue;
-    const groupRow = groupingColumns.length === 0 ? {} : Object.fromEntries(
-      groupingColumns.map((column) => [column, row[column] ?? null])
-    );
-    const key = groupingColumns.length === 0 ? "__smrt_global_group__" : JSON.stringify(groupingColumns.map((column) => groupRow[column]));
-    if (!groups.has(key)) {
-      groups.set(key, groupRow);
-    }
-  }
-  return [...groups.values()];
+	const groupingColumns = getActualGroupingColumns(definition);
+	const groups = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (!row) continue;
+		const groupRow = groupingColumns.length === 0 ? {} : Object.fromEntries(groupingColumns.map((column) => [column, row[column] ?? null]));
+		const key = groupingColumns.length === 0 ? "__smrt_global_group__" : JSON.stringify(groupingColumns.map((column) => groupRow[column]));
+		if (!groups.has(key)) groups.set(key, groupRow);
+	}
+	return [...groups.values()];
 }
 async function readMaterializedGroups(db, tableName, definition, scope) {
-  const groupingColumns = getActualGroupingColumns(definition);
-  if (groupingColumns.length === 0) {
-    return [{}];
-  }
-  const where = scope.reportTenantColumn ? predicateSql(tableName, { [scope.reportTenantColumn]: scope.tenantId }) : { sql: "", values: [] };
-  const columns = groupingColumns.map((column) => validateColumnName(column));
-  const result = await db.query(
-    `SELECT ${columns.join(", ")} FROM ${validateColumnName(tableName)} ${where.sql}`,
-    ...where.values
-  );
-  return result.rows.map((row) => parseMaybeJson(row)).filter((row) => Boolean(row));
+	const groupingColumns = getActualGroupingColumns(definition);
+	if (groupingColumns.length === 0) return [{}];
+	const where = scope.reportTenantColumn ? predicateSql(tableName, { [scope.reportTenantColumn]: scope.tenantId }) : {
+		sql: "",
+		values: []
+	};
+	const columns = groupingColumns.map((column) => validateColumnName(column));
+	return (await db.query(`SELECT ${columns.join(", ")} FROM ${validateColumnName(tableName)} ${where.sql}`, ...where.values)).rows.map((row) => parseMaybeJson(row)).filter((row) => Boolean(row));
 }
 async function deleteMaterializedGroup(db, tableName, definition, scope, groupRow) {
-  const predicate = {};
-  if (scope.reportTenantColumn) {
-    predicate[scope.reportTenantColumn] = scope.tenantId;
-  }
-  for (const column of getActualGroupingColumns(definition)) {
-    predicate[column] = groupRow[column];
-  }
-  const where = predicateSql(tableName, predicate);
-  await db.query(
-    `DELETE FROM ${validateColumnName(tableName)} ${where.sql}`,
-    ...where.values
-  );
+	const predicate = {};
+	if (scope.reportTenantColumn) predicate[scope.reportTenantColumn] = scope.tenantId;
+	for (const column of getActualGroupingColumns(definition)) predicate[column] = groupRow[column];
+	const where = predicateSql(tableName, predicate);
+	await db.query(`DELETE FROM ${validateColumnName(tableName)} ${where.sql}`, ...where.values);
 }
 async function replaceRows(db, tableName, rows, scope) {
-  validateColumnName(tableName);
-  const run = async (tx) => {
-    if (scope.reportTenantColumn) {
-      const where = predicateSql(tableName, {
-        [scope.reportTenantColumn]: scope.tenantId
-      });
-      await tx.query(`DELETE FROM ${tableName} ${where.sql}`, ...where.values);
-    } else {
-      await tx.query(`DELETE FROM ${tableName}`);
-    }
-    if (rows.length > 0) {
-      await tx.insert(tableName, rows);
-    }
-  };
-  if (db.transaction) {
-    await db.transaction(run);
-    return;
-  }
-  await run(db);
+	validateColumnName(tableName);
+	const run = async (tx) => {
+		if (scope.reportTenantColumn) {
+			const where = predicateSql(tableName, { [scope.reportTenantColumn]: scope.tenantId });
+			await tx.query(`DELETE FROM ${tableName} ${where.sql}`, ...where.values);
+		} else await tx.query(`DELETE FROM ${tableName}`);
+		if (rows.length > 0) await tx.insert(tableName, rows);
+	};
+	if (db.transaction) {
+		await db.transaction(run);
+		return;
+	}
+	await run(db);
 }
 function parseMaybeJson(value) {
-  if (value == null) return null;
-  if (typeof value !== "string") return value;
-  try {
-    return JSON.parse(value);
-  } catch {
-    return value;
-  }
+	if (value == null) return null;
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
 }
 function watermarkValue(value) {
-  if (value === null || value === void 0) return null;
-  if (value instanceof Date) return value.toISOString();
-  return String(value);
+	if (value === null || value === void 0) return null;
+	if (value instanceof Date) return value.toISOString();
+	return String(value);
 }
 async function readWatermark(db, definition, scope, watermarkColumn) {
-  const result = await db.query(
-    `SELECT watermark_value FROM ${REPORT_WATERMARKS_TABLE}
+	const row = (await db.query(`SELECT watermark_value FROM ${REPORT_WATERMARKS_TABLE}
       WHERE report_class = ?
         AND scope_key = ?
         AND source_class = ?
         AND watermark_column = ?
-      LIMIT 1`,
-    definition.reportClassName,
-    scope.scopeKey,
-    definition.sourceClassName,
-    watermarkColumn
-  );
-  const row = result.rows[0];
-  return watermarkValue(row?.watermark_value);
+      LIMIT 1`, definition.reportClassName, scope.scopeKey, definition.sourceClassName, watermarkColumn)).rows[0];
+	return watermarkValue(row?.watermark_value);
 }
 async function writeWatermark(db, definition, scope, watermarkColumn, value, runId) {
-  if (value === null) return;
-  const id = stableReportId([
-    "watermark",
-    definition.reportClassName,
-    scope.scopeKey,
-    definition.sourceClassName,
-    watermarkColumn
-  ]);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  await db.upsert(
-    REPORT_WATERMARKS_TABLE,
-    ["report_class", "scope_key", "source_class", "watermark_column"],
-    {
-      id,
-      slug: id,
-      context: scope.scopeKey,
-      tenant_id: scope.tenantId,
-      scope_key: scope.scopeKey,
-      report_class: definition.reportClassName,
-      source_class: definition.sourceClassName,
-      watermark_column: watermarkColumn,
-      watermark_value: value,
-      last_run_id: runId ?? null,
-      created_at: now,
-      updated_at: now
-    }
-  );
+	if (value === null) return;
+	const id = stableReportId([
+		"watermark",
+		definition.reportClassName,
+		scope.scopeKey,
+		definition.sourceClassName,
+		watermarkColumn
+	]);
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	await db.upsert(REPORT_WATERMARKS_TABLE, [
+		"report_class",
+		"scope_key",
+		"source_class",
+		"watermark_column"
+	], {
+		id,
+		slug: id,
+		context: scope.scopeKey,
+		tenant_id: scope.tenantId,
+		scope_key: scope.scopeKey,
+		report_class: definition.reportClassName,
+		source_class: definition.sourceClassName,
+		watermark_column: watermarkColumn,
+		watermark_value: value,
+		last_run_id: runId ?? null,
+		created_at: now,
+		updated_at: now
+	});
 }
 async function maxWatermark(db, definition, scope, watermarkColumn, adapterType) {
-  const where = andWhere(void 0, tenantWhere(scope));
-  const builtWhere = where ? buildWhere(where, 1, adapterType) : { sql: "", values: [] };
-  const result = await db.query(
-    `SELECT MAX(${validateColumnName(watermarkColumn)}) AS watermark FROM ${validateColumnName(definition.sourceTable)} ${builtWhere.sql}`,
-    ...builtWhere.values
-  );
-  const row = result.rows[0];
-  return watermarkValue(row?.watermark);
+	const where = andWhere(void 0, tenantWhere(scope));
+	const builtWhere = where ? buildWhere(where, 1, adapterType) : {
+		sql: "",
+		values: []
+	};
+	const row = (await db.query(`SELECT MAX(${validateColumnName(watermarkColumn)}) AS watermark FROM ${validateColumnName(definition.sourceTable)} ${builtWhere.sql}`, ...builtWhere.values)).rows[0];
+	return watermarkValue(row?.watermark);
 }
 async function startRun(db, definition, scope, options, mode, watermarkBefore) {
-  if (options.trackRuns === false) return void 0;
-  const id = randomUUID();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  await db.insert(REPORT_RUNS_TABLE, {
-    id,
-    slug: id,
-    context: scope.scopeKey,
-    tenant_id: scope.tenantId,
-    scope_key: scope.scopeKey,
-    report_class: definition.reportClassName,
-    source_class: definition.sourceClassName,
-    mode,
-    trigger: options.trigger ?? "manual",
-    status: "running",
-    started_at: now,
-    row_count: 0,
-    changed_group_count: 0,
-    watermark_before: null,
-    watermark_after: null,
-    error: null,
-    metadata: {
-      scheduleId: options.scheduleId
-    },
-    created_at: now,
-    updated_at: now
-  });
-  return id;
+	if (options.trackRuns === false) return void 0;
+	const id = randomUUID();
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	await db.insert(REPORT_RUNS_TABLE, {
+		id,
+		slug: id,
+		context: scope.scopeKey,
+		tenant_id: scope.tenantId,
+		scope_key: scope.scopeKey,
+		report_class: definition.reportClassName,
+		source_class: definition.sourceClassName,
+		mode,
+		trigger: options.trigger ?? "manual",
+		status: "running",
+		started_at: now,
+		row_count: 0,
+		changed_group_count: 0,
+		watermark_before: watermarkBefore ?? null,
+		watermark_after: null,
+		error: null,
+		metadata: { scheduleId: options.scheduleId },
+		created_at: now,
+		updated_at: now
+	});
+	return id;
 }
 async function completeRun(db, runId, status, data = {}) {
-  if (!runId) return;
-  const error = data.error instanceof Error ? data.error.message : data.error ? String(data.error) : null;
-  await db.update(
-    REPORT_RUNS_TABLE,
-    { id: runId },
-    {
-      status,
-      completed_at: (/* @__PURE__ */ new Date()).toISOString(),
-      row_count: data.rowCount ?? 0,
-      changed_group_count: data.changedGroupCount ?? 0,
-      watermark_after: data.watermarkAfter ?? null,
-      error,
-      updated_at: (/* @__PURE__ */ new Date()).toISOString()
-    }
-  );
+	if (!runId) return;
+	const error = data.error instanceof Error ? data.error.message : data.error ? String(data.error) : null;
+	await db.update(REPORT_RUNS_TABLE, { id: runId }, {
+		status,
+		completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+		row_count: data.rowCount ?? 0,
+		changed_group_count: data.changedGroupCount ?? 0,
+		watermark_after: data.watermarkAfter ?? null,
+		error,
+		updated_at: (/* @__PURE__ */ new Date()).toISOString()
+	});
 }
 async function acquireLock(db, definition, scope, ttlMs) {
-  const now = /* @__PURE__ */ new Date();
-  const nowIso = now.toISOString();
-  const ownerId = randomUUID();
-  const expiresAt = new Date(now.getTime() + ttlMs);
-  const expiresAtIso = expiresAt.toISOString();
-  const id = stableReportId([
-    "lock",
-    definition.reportClassName,
-    scope.scopeKey
-  ]);
-  await db.query(
-    `INSERT INTO ${REPORT_LOCKS_TABLE} (
+	const now = /* @__PURE__ */ new Date();
+	const nowIso = now.toISOString();
+	const ownerId = randomUUID();
+	const expiresAtIso = new Date(now.getTime() + ttlMs).toISOString();
+	const id = stableReportId([
+		"lock",
+		definition.reportClassName,
+		scope.scopeKey
+	]);
+	await db.query(`INSERT INTO ${REPORT_LOCKS_TABLE} (
         id,
         slug,
         context,
@@ -446,333 +362,173 @@ async function acquireLock(db, definition, scope, ttlMs) {
         updated_at = excluded.updated_at
       WHERE ${REPORT_LOCKS_TABLE}.owner_id IS NULL
         OR ${REPORT_LOCKS_TABLE}.expires_at IS NULL
-        OR ${REPORT_LOCKS_TABLE}.expires_at <= ?`,
-    id,
-    id,
-    scope.scopeKey,
-    scope.tenantId,
-    scope.scopeKey,
-    definition.reportClassName,
-    ownerId,
-    nowIso,
-    nowIso,
-    expiresAtIso,
-    nowIso,
-    nowIso,
-    nowIso
-  );
-  const claimed = await db.query(
-    `SELECT owner_id FROM ${REPORT_LOCKS_TABLE}
+        OR ${REPORT_LOCKS_TABLE}.expires_at <= ?`, id, id, scope.scopeKey, scope.tenantId, scope.scopeKey, definition.reportClassName, ownerId, nowIso, nowIso, expiresAtIso, nowIso, nowIso, nowIso);
+	if ((await db.query(`SELECT owner_id FROM _smrt_report_locks
       WHERE report_class = ? AND scope_key = ?
-      LIMIT 1`,
-    definition.reportClassName,
-    scope.scopeKey
-  );
-  const row = claimed.rows[0];
-  if (row?.owner_id !== ownerId) {
-    return null;
-  }
-  return {
-    ownerId,
-    async release() {
-      await db.query(
-        `UPDATE ${REPORT_LOCKS_TABLE}
+      LIMIT 1`, definition.reportClassName, scope.scopeKey)).rows[0]?.owner_id !== ownerId) return null;
+	return {
+		ownerId,
+		async release() {
+			await db.query(`UPDATE ${REPORT_LOCKS_TABLE}
             SET owner_id = NULL,
                 heartbeat_at = NULL,
                 expires_at = NULL,
                 updated_at = ?
           WHERE report_class = ?
             AND scope_key = ?
-            AND owner_id = ?`,
-        (/* @__PURE__ */ new Date()).toISOString(),
-        definition.reportClassName,
-        scope.scopeKey,
-        ownerId
-      );
-    }
-  };
+            AND owner_id = ?`, (/* @__PURE__ */ new Date()).toISOString(), definition.reportClassName, scope.scopeKey, ownerId);
+		}
+	};
 }
 async function rebuildReport(db, definition, reportTable, scope, adapterType, runId, watermark) {
-  const explicitWatermarkColumn = definition.refresh?.watermarkColumn && await fieldColumn(
-    definition.sourceClassName,
-    definition.refresh.watermarkColumn
-  );
-  const explicitSoftDeleteColumn = definition.refresh?.softDeleteColumn && await fieldColumn(
-    definition.sourceClassName,
-    definition.refresh.softDeleteColumn
-  );
-  const watermarkColumn = watermark?.watermarkColumn ?? explicitWatermarkColumn ?? null;
-  const softDeleteColumn = watermark?.softDeleteColumn ?? explicitSoftDeleteColumn ?? null;
-  const deletedFilter = softDeleteColumn ? { [softDeleteColumn]: null } : {};
-  const spec = withRefreshFilters(
-    compileReportDefinition(definition),
-    scope,
-    deletedFilter
-  );
-  const aggregate = buildAggregate(spec, 1, adapterType);
-  const result = await db.query(aggregate.sql, ...aggregate.values);
-  const refreshedAt = /* @__PURE__ */ new Date();
-  const rows = materializeRows(result.rows, definition, refreshedAt, scope);
-  await replaceRows(db, reportTable, rows, scope);
-  const watermarkAfter = watermarkColumn ? await maxWatermark(db, definition, scope, watermarkColumn, adapterType) : null;
-  if (watermarkColumn) {
-    await writeWatermark(
-      db,
-      definition,
-      scope,
-      watermarkColumn,
-      watermarkAfter,
-      runId
-    );
-  }
-  return {
-    rowCount: rows.length,
-    changedGroupCount: rows.length,
-    watermarkAfter,
-    mode: "rebuild"
-  };
+	const explicitWatermarkColumn = definition.refresh?.watermarkColumn && await fieldColumn(definition.sourceClassName, definition.refresh.watermarkColumn);
+	const explicitSoftDeleteColumn = definition.refresh?.softDeleteColumn && await fieldColumn(definition.sourceClassName, definition.refresh.softDeleteColumn);
+	const watermarkColumn = watermark?.watermarkColumn ?? explicitWatermarkColumn ?? null;
+	const softDeleteColumn = watermark?.softDeleteColumn ?? explicitSoftDeleteColumn ?? null;
+	const deletedFilter = softDeleteColumn ? { [softDeleteColumn]: null } : {};
+	const aggregate = buildAggregate(withRefreshFilters(compileReportDefinition(definition), scope, deletedFilter), 1, adapterType);
+	const result = await db.query(aggregate.sql, ...aggregate.values);
+	const refreshedAt = /* @__PURE__ */ new Date();
+	const rows = materializeRows(result.rows, definition, refreshedAt, scope);
+	await replaceRows(db, reportTable, rows, scope);
+	const watermarkAfter = watermarkColumn ? await maxWatermark(db, definition, scope, watermarkColumn, adapterType) : null;
+	if (watermarkColumn) await writeWatermark(db, definition, scope, watermarkColumn, watermarkAfter, runId);
+	return {
+		rowCount: rows.length,
+		changedGroupCount: rows.length,
+		watermarkAfter,
+		mode: "rebuild"
+	};
 }
 async function incrementalReport(db, definition, reportTable, scope, adapterType, runId, changedRows = []) {
-  const watermark = await resolveWatermarkConfig(definition);
-  const watermarkBefore = await readWatermark(
-    db,
-    definition,
-    scope,
-    watermark.watermarkColumn
-  );
-  if (!watermarkBefore) {
-    const seeded = await rebuildReport(
-      db,
-      definition,
-      reportTable,
-      scope,
-      adapterType,
-      runId,
-      watermark
-    );
-    return {
-      ...seeded,
-      watermarkBefore
-    };
-  }
-  const changedSpec = compileChangedGroupSpec(
-    definition,
-    scope,
-    watermark,
-    watermarkBefore
-  );
-  const changedAggregate = buildAggregate(changedSpec, 1, adapterType);
-  const changed = await db.query(
-    changedAggregate.sql,
-    ...changedAggregate.values
-  );
-  const changedGroups = changed.rows.map(
-    (row) => parseMaybeJson(row)
-  );
-  const materializedGroups = changedGroups.length > 0 || changedRows.length > 0 ? await readMaterializedGroups(db, reportTable, definition, scope) : [];
-  const affectedGroups = dedupeGroupRows(definition, [
-    ...changedGroups,
-    ...materializedGroups
-  ]);
-  if (affectedGroups.length === 0) {
-    return {
-      rowCount: 0,
-      changedGroupCount: 0,
-      watermarkBefore,
-      watermarkAfter: watermarkBefore,
-      mode: "incremental"
-    };
-  }
-  let rowCount = 0;
-  const conflicts = conflictColumns(definition, scope);
-  for (const groupRow of affectedGroups) {
-    const affectedSpec = compileAffectedGroupSpec(
-      definition,
-      scope,
-      watermark,
-      groupRow
-    );
-    const aggregate = buildAggregate(affectedSpec, 1, adapterType);
-    const result = await db.query(aggregate.sql, ...aggregate.values);
-    const refreshedAt = /* @__PURE__ */ new Date();
-    const rows = materializeRows(result.rows, definition, refreshedAt, scope);
-    if (rows.length === 0) {
-      await deleteMaterializedGroup(
-        db,
-        reportTable,
-        definition,
-        scope,
-        groupRow
-      );
-      continue;
-    }
-    for (const row of rows) {
-      await db.upsert(reportTable, conflicts, row);
-      rowCount += 1;
-    }
-  }
-  const watermarkAfter = await maxWatermark(
-    db,
-    definition,
-    scope,
-    watermark.watermarkColumn,
-    adapterType
-  );
-  await writeWatermark(
-    db,
-    definition,
-    scope,
-    watermark.watermarkColumn,
-    watermarkAfter,
-    runId
-  );
-  return {
-    rowCount,
-    changedGroupCount: affectedGroups.length,
-    watermarkBefore,
-    watermarkAfter,
-    mode: "incremental"
-  };
+	const watermark = await resolveWatermarkConfig(definition);
+	const watermarkBefore = await readWatermark(db, definition, scope, watermark.watermarkColumn);
+	if (!watermarkBefore) return {
+		...await rebuildReport(db, definition, reportTable, scope, adapterType, runId, watermark),
+		watermarkBefore
+	};
+	const changedAggregate = buildAggregate(compileChangedGroupSpec(definition, scope, watermark, watermarkBefore), 1, adapterType);
+	const changedGroups = (await db.query(changedAggregate.sql, ...changedAggregate.values)).rows.map((row) => parseMaybeJson(row));
+	const materializedGroups = changedGroups.length > 0 || changedRows.length > 0 ? await readMaterializedGroups(db, reportTable, definition, scope) : [];
+	const affectedGroups = dedupeGroupRows(definition, [...changedGroups, ...materializedGroups]);
+	if (affectedGroups.length === 0) return {
+		rowCount: 0,
+		changedGroupCount: 0,
+		watermarkBefore,
+		watermarkAfter: watermarkBefore,
+		mode: "incremental"
+	};
+	let rowCount = 0;
+	const conflicts = conflictColumns(definition, scope);
+	for (const groupRow of affectedGroups) {
+		const aggregate = buildAggregate(compileAffectedGroupSpec(definition, scope, watermark, groupRow), 1, adapterType);
+		const result = await db.query(aggregate.sql, ...aggregate.values);
+		const refreshedAt = /* @__PURE__ */ new Date();
+		const rows = materializeRows(result.rows, definition, refreshedAt, scope);
+		if (rows.length === 0) {
+			await deleteMaterializedGroup(db, reportTable, definition, scope, groupRow);
+			continue;
+		}
+		for (const row of rows) {
+			await db.upsert(reportTable, conflicts, row);
+			rowCount += 1;
+		}
+	}
+	const watermarkAfter = await maxWatermark(db, definition, scope, watermark.watermarkColumn, adapterType);
+	await writeWatermark(db, definition, scope, watermark.watermarkColumn, watermarkAfter, runId);
+	return {
+		rowCount,
+		changedGroupCount: affectedGroups.length,
+		watermarkBefore,
+		watermarkAfter,
+		mode: "incremental"
+	};
 }
 function requiredReportRuntimeTables(mode, options) {
-  const tables = /* @__PURE__ */ new Set();
-  if (options.trackRuns !== false) tables.add(REPORT_RUNS_TABLE);
-  if (mode === "incremental") tables.add(REPORT_WATERMARKS_TABLE);
-  if (options.lock !== false) tables.add(REPORT_LOCKS_TABLE);
-  return [...tables];
+	const tables = /* @__PURE__ */ new Set();
+	if (options.trackRuns !== false) tables.add(REPORT_RUNS_TABLE);
+	if (mode === "incremental") tables.add(REPORT_WATERMARKS_TABLE);
+	if (options.lock !== false) tables.add(REPORT_LOCKS_TABLE);
+	return [...tables];
 }
 async function refreshReportOnce(reportCtor, options) {
-  if (!options.db) {
-    throw new Error("refreshReport requires a database handle");
-  }
-  const definition = await buildReportDefinition(reportCtor);
-  const reportTable = getReportTableName(reportCtor);
-  const requestedMode = options.mode ?? definition.refresh?.mode ?? "rebuild";
-  const exists = await tableExists(options.db, reportTable);
-  if (!exists) {
-    throw new Error(
-      `Report table '${reportTable}' does not exist for ${reportCtor.name}. Run smrt db:migrate before refreshing reports.`
-    );
-  }
-  const requiredTables = requiredReportRuntimeTables(requestedMode, options);
-  if (requiredTables.length > 0) {
-    await assertReportTablesReady(options.db, requiredTables);
-  }
-  const adapterType = adapterTypeFromDb(options.db, options.adapterType);
-  const scope = await resolveScope(definition, options);
-  const lock = options.lock === false ? null : await acquireLock(
-    options.db,
-    definition,
-    scope,
-    options.lockTtlMs ?? 15 * 60 * 1e3
-  );
-  if (options.lock !== false && !lock) {
-    const runId2 = await startRun(
-      options.db,
-      definition,
-      scope,
-      options,
-      requestedMode
-    );
-    await completeRun(options.db, runId2, "skipped");
-    return {
-      rowCount: 0,
-      refreshedAt: /* @__PURE__ */ new Date(),
-      mode: requestedMode,
-      tenantId: scope.tenantId,
-      runId: runId2,
-      changedGroupCount: 0,
-      skipped: true
-    };
-  }
-  let runId;
-  try {
-    runId = await startRun(
-      options.db,
-      definition,
-      scope,
-      options,
-      requestedMode
-    );
-    const work = requestedMode === "incremental" ? await incrementalReport(
-      options.db,
-      definition,
-      reportTable,
-      scope,
-      adapterType,
-      runId,
-      options.changedRows
-    ) : await rebuildReport(
-      options.db,
-      definition,
-      reportTable,
-      scope,
-      adapterType,
-      runId
-    );
-    await completeRun(options.db, runId, "success", {
-      rowCount: work.rowCount,
-      changedGroupCount: work.changedGroupCount,
-      watermarkAfter: work.watermarkAfter
-    });
-    return {
-      rowCount: work.rowCount,
-      refreshedAt: /* @__PURE__ */ new Date(),
-      mode: work.mode,
-      tenantId: scope.tenantId,
-      runId,
-      changedGroupCount: work.changedGroupCount
-    };
-  } catch (error) {
-    await completeRun(options.db, runId, "failed", { error });
-    throw error;
-  } finally {
-    await lock?.release();
-  }
+	if (!options.db) throw new Error("refreshReport requires a database handle");
+	const definition = await buildReportDefinition(reportCtor);
+	const reportTable = getReportTableName(reportCtor);
+	const requestedMode = options.mode ?? definition.refresh?.mode ?? "rebuild";
+	if (!await tableExists(options.db, reportTable)) throw new Error(`Report table '${reportTable}' does not exist for ${reportCtor.name}. Run smrt db:migrate before refreshing reports.`);
+	const requiredTables = requiredReportRuntimeTables(requestedMode, options);
+	if (requiredTables.length > 0) await assertReportTablesReady(options.db, requiredTables);
+	const adapterType = adapterTypeFromDb(options.db, options.adapterType);
+	const scope = await resolveScope(definition, options);
+	const lock = options.lock === false ? null : await acquireLock(options.db, definition, scope, options.lockTtlMs ?? 900 * 1e3);
+	if (options.lock !== false && !lock) {
+		const runId2 = await startRun(options.db, definition, scope, options, requestedMode);
+		await completeRun(options.db, runId2, "skipped");
+		return {
+			rowCount: 0,
+			refreshedAt: /* @__PURE__ */ new Date(),
+			mode: requestedMode,
+			tenantId: scope.tenantId,
+			runId: runId2,
+			changedGroupCount: 0,
+			skipped: true
+		};
+	}
+	let runId;
+	try {
+		runId = await startRun(options.db, definition, scope, options, requestedMode);
+		const work = requestedMode === "incremental" ? await incrementalReport(options.db, definition, reportTable, scope, adapterType, runId, options.changedRows) : await rebuildReport(options.db, definition, reportTable, scope, adapterType, runId);
+		await completeRun(options.db, runId, "success", {
+			rowCount: work.rowCount,
+			changedGroupCount: work.changedGroupCount,
+			watermarkAfter: work.watermarkAfter
+		});
+		return {
+			rowCount: work.rowCount,
+			refreshedAt: /* @__PURE__ */ new Date(),
+			mode: work.mode,
+			tenantId: scope.tenantId,
+			runId,
+			changedGroupCount: work.changedGroupCount
+		};
+	} catch (error) {
+		await completeRun(options.db, runId, "failed", { error });
+		throw error;
+	} finally {
+		await lock?.release();
+	}
 }
 async function refreshReport(reportCtor, options = {}) {
-  if (options.tenantIds && options.tenantIds.length > 0) {
-    if (!options.db) {
-      throw new Error("refreshReport requires a database handle");
-    }
-    const results = [];
-    for (const tenantId of options.tenantIds) {
-      const result = await withTenant(
-        { tenantId },
-        () => refreshReportOnce(reportCtor, {
-          ...options,
-          tenantId,
-          tenantIds: void 0
-        })
-      );
-      results.push(result);
-    }
-    return {
-      rowCount: results.reduce((sum, result) => sum + result.rowCount, 0),
-      refreshedAt: /* @__PURE__ */ new Date(),
-      mode: results[0]?.mode ?? options.mode ?? "rebuild",
-      tenantId: null,
-      changedGroupCount: results.reduce(
-        (sum, result) => sum + (result.changedGroupCount ?? 0),
-        0
-      ),
-      tenantResults: results
-    };
-  }
-  return refreshReportOnce(reportCtor, options);
+	if (options.tenantIds && options.tenantIds.length > 0) {
+		if (!options.db) throw new Error("refreshReport requires a database handle");
+		const results = [];
+		for (const tenantId of options.tenantIds) {
+			const result = await withTenant({ tenantId }, () => refreshReportOnce(reportCtor, {
+				...options,
+				tenantId,
+				tenantIds: void 0
+			}));
+			results.push(result);
+		}
+		return {
+			rowCount: results.reduce((sum, result) => sum + result.rowCount, 0),
+			refreshedAt: /* @__PURE__ */ new Date(),
+			mode: results[0]?.mode ?? options.mode ?? "rebuild",
+			tenantId: null,
+			changedGroupCount: results.reduce((sum, result) => sum + (result.changedGroupCount ?? 0), 0),
+			tenantResults: results
+		};
+	}
+	return refreshReportOnce(reportCtor, options);
 }
 function reportRowIdentity(row, definition) {
-  const groupingColumns = getReportGroupingColumns(definition);
-  return stableReportId(
-    groupingColumns.map((column) => row[toSnakeCase(column)])
-  );
+	return stableReportId(getReportGroupingColumns(definition).map((column) => row[toSnakeCase(column)]));
 }
 function reportSourceClassName(source) {
-  return sourceClassName(source);
-}
-export {
-  refreshReport,
-  reportRowIdentity,
-  reportSourceClassName
-};
-//# sourceMappingURL=refresh.js.map
+	return sourceClassName(source);
+}
+//#endregion
+export { refreshReport, reportRowIdentity, reportSourceClassName };
+
+//# sourceMappingURL=refresh.js.map