@happyvertical/smrt-reports 0.36.5

package/dist/refresh.js

@@ -0,0 +1,778 @@
+import { createHash, randomUUID } from "node:crypto";
+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";
+function isSqlAdapterType(value) {
+  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 }."
+  );
+}
+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("-");
+}
+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;
+}
+function getActualGroupingColumns(definition) {
+  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
+    };
+  });
+}
+function sourceClassName(source) {
+  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;
+}
+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;
+}
+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
+  };
+}
+function tenantWhere(scope) {
+  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 };
+}
+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 };
+}
+function withRefreshFilters(spec, 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 };
+}
+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 }
+  );
+}
+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)
+  };
+}
+function conflictColumns(definition, scope) {
+  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
+  };
+}
+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()];
+}
+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));
+}
+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
+  );
+}
+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);
+}
+function parseMaybeJson(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);
+}
+async function readWatermark(db, definition, scope, watermarkColumn) {
+  const result = 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);
+}
+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
+    }
+  );
+}
+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);
+}
+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;
+}
+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()
+    }
+  );
+}
+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} (
+        id,
+        slug,
+        context,
+        tenant_id,
+        scope_key,
+        report_class,
+        owner_id,
+        acquired_at,
+        heartbeat_at,
+        expires_at,
+        created_at,
+        updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(report_class, scope_key) DO UPDATE SET
+        tenant_id = excluded.tenant_id,
+        owner_id = excluded.owner_id,
+        acquired_at = excluded.acquired_at,
+        heartbeat_at = excluded.heartbeat_at,
+        expires_at = excluded.expires_at,
+        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}
+      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}
+            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
+      );
+    }
+  };
+}
+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"
+  };
+}
+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"
+  };
+}
+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];
+}
+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();
+  }
+}
+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);
+}
+function reportRowIdentity(row, definition) {
+  const groupingColumns = getReportGroupingColumns(definition);
+  return stableReportId(
+    groupingColumns.map((column) => row[toSnakeCase(column)])
+  );
+}
+function reportSourceClassName(source) {
+  return sourceClassName(source);
+}
+export {
+  refreshReport,
+  reportRowIdentity,
+  reportSourceClassName
+};
+//# sourceMappingURL=refresh.js.map