@agent-native/core 0.145.5 → 0.145.7

package/corpus/templates/analytics/server/lib/analytics-query-catalog.ts

@@ -1,10 +1,16 @@
 import { getAllSettings, listOrgSettings } from "@agent-native/core/settings";
 
 import { dashboardCatalogEntries } from "./dashboard-catalog";
-import { listDashboards, type DashboardRecord } from "./dashboards-store";
+import {
+  listDashboardSummaries,
+  loadDashboardCatalogDashboards,
+  type DashboardCatalogRecord,
+  type DashboardSummaryRecord,
+} from "./dashboards-store";
 
 const DATA_DICTIONARY_KEY_PREFIX = "data-dict-";
 const MAX_QUERY_LENGTH = 12_000;
+const MAX_CATALOG_DASHBOARD_HYDRATION = 24;
 const STOP_WORDS = new Set([
   "a",
   "all",
@@ -106,6 +112,44 @@ function compactQuery(value: unknown): string | Record<string, unknown> | null {
   return null;
 }
 
+function summaryScore(
+  search: string,
+  dashboard: DashboardSummaryRecord,
+): number {
+  const { score } = matchScore(search, [
+    { value: dashboard.name, weight: 24 },
+    { value: dashboard.description, weight: 12 },
+    { value: dashboard.configName, weight: 10 },
+    { value: dashboard.catalogTemplateId, weight: 6 },
+    { value: dashboard.demoId, weight: 6 },
+  ]);
+  return score;
+}
+
+function shortlistDashboardSummaries(
+  search: string,
+  dashboards: DashboardSummaryRecord[],
+  limit: number,
+): DashboardSummaryRecord[] {
+  const maxHydration = Math.min(
+    Math.max(limit * 4, 12),
+    MAX_CATALOG_DASHBOARD_HYDRATION,
+  );
+  return dashboards
+    .map((dashboard) => ({
+      dashboard,
+      score: summaryScore(search, dashboard),
+    }))
+    .sort((a, b) => {
+      if (b.score !== a.score) return b.score - a.score;
+      return JSON.stringify(a.dashboard).localeCompare(
+        JSON.stringify(b.dashboard),
+      );
+    })
+    .slice(0, maxHydration)
+    .map(({ dashboard }) => dashboard);
+}
+
 // Analytics vocabulary the corpus spells out but users abbreviate (or vice versa).
 // Expansions match at reduced weight so they break ties without outranking a literal hit.
 const SYNONYM_EXPANSIONS: Record<string, string[]> = {
@@ -497,13 +541,15 @@ async function listDictionaryEntries(args: {
   return entries;
 }
 
-function savedDashboardInput(dashboard: DashboardRecord) {
-  const config = dashboard.config as Record<string, unknown>;
+function savedDashboardInput(
+  summary: DashboardSummaryRecord,
+  dashboard: DashboardCatalogRecord,
+) {
   return {
     id: dashboard.id,
-    title: text(config.name) || dashboard.title,
-    description: text(config.description) || undefined,
-    config,
+    title: summary.name,
+    description: summary.description ?? undefined,
+    config: dashboard.config,
     origin: "saved-dashboard" as const,
   };
 }
@@ -514,26 +560,46 @@ export async function searchAnalyticsQueryCatalog(args: {
   orgId: string | null;
   limit: number;
 }): Promise<AnalyticsQueryCatalogCandidate[]> {
-  const [savedDashboardsResult, dictionaryEntriesResult] =
+  const [savedSummariesResult, dictionaryEntriesResult] =
     await Promise.allSettled([
-      listDashboards(
+      listDashboardSummaries(
         { email: args.email, orgId: args.orgId },
-        { kind: "sql", archived: "active", hidden: "visible" },
+        {
+          kind: "sql",
+          archived: "active",
+          hidden: "visible",
+          includeCatalogMetadata: true,
+        },
       ),
       listDictionaryEntries({ email: args.email, orgId: args.orgId }),
     ]);
-  const savedDashboards =
-    savedDashboardsResult.status === "fulfilled"
-      ? savedDashboardsResult.value
+  const savedSummaries =
+    savedSummariesResult.status === "fulfilled"
+      ? savedSummariesResult.value
       : [];
   const dictionaryEntries =
     dictionaryEntriesResult.status === "fulfilled"
       ? dictionaryEntriesResult.value
       : [];
+  const savedSummaryIds = new Set(
+    savedSummaries.map((dashboard) => dashboard.id),
+  );
 
-  const savedIds = new Set(savedDashboards.map((dashboard) => dashboard.id));
+  const shortlistedSummaries = shortlistDashboardSummaries(
+    args.search,
+    savedSummaries,
+    args.limit,
+  );
+  const shortlistedIds = shortlistedSummaries.map((dashboard) => dashboard.id);
+  const savedDashboardsResult = await loadDashboardCatalogDashboards(
+    { email: args.email, orgId: args.orgId },
+    shortlistedIds,
+  );
+  const savedDashboards = new Map(
+    savedDashboardsResult.map((dashboard) => [dashboard.id, dashboard]),
+  );
   const templateDashboards = dashboardCatalogEntries
-    .filter((entry) => !savedIds.has(entry.defaultDashboardId))
+    .filter((entry) => !savedSummaryIds.has(entry.defaultDashboardId))
     .flatMap((entry) => {
       try {
         const config = entry.buildConfig() as unknown as Record<
@@ -557,7 +623,11 @@ export async function searchAnalyticsQueryCatalog(args: {
   return rankAnalyticsQueryCatalog({
     search: args.search,
     dashboards: [
-      ...savedDashboards.map(savedDashboardInput),
+      ...shortlistedSummaries.flatMap((summary) => {
+        const dashboard = savedDashboards.get(summary.id);
+        if (!dashboard) return [];
+        return [savedDashboardInput(summary, dashboard)];
+      }),
       ...templateDashboards,
     ],
     dictionaryEntries,

package/corpus/templates/analytics/server/lib/dashboard-folders-store.ts

@@ -0,0 +1,168 @@
+import { recordChange } from "@agent-native/core/server";
+import { accessFilter, assertAccess } from "@agent-native/core/sharing";
+import { desc, eq } from "drizzle-orm";
+
+import { getDb, schema } from "../db/index.js";
+import { type DashboardRecord, getDashboard } from "./dashboards-store.js";
+
+export type DashboardFolderScope = "personal" | "shared";
+
+export interface DashboardFolderContext {
+  email: string;
+  orgId: string | null;
+}
+
+export interface DashboardFolderRecord {
+  id: string;
+  name: string;
+  scope: DashboardFolderScope;
+  ownerEmail: string;
+  orgId: string | null;
+  visibility: "private" | "org" | "public";
+  createdAt: string;
+  updatedAt: string;
+}
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function toFolder(row: any): DashboardFolderRecord {
+  return {
+    id: row.id,
+    name: row.name,
+    scope: row.scope,
+    ownerEmail: row.ownerEmail,
+    orgId: row.orgId ?? null,
+    visibility: row.visibility,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}
+
+export async function listDashboardFolders(
+  ctx: DashboardFolderContext,
+): Promise<DashboardFolderRecord[]> {
+  const rows = await (getDb() as any)
+    .select()
+    .from(schema.dashboardFolders)
+    .where(
+      accessFilter(schema.dashboardFolders, schema.dashboardFolderShares, {
+        userEmail: ctx.email,
+        orgId: ctx.orgId ?? undefined,
+      }),
+    )
+    .orderBy(desc(schema.dashboardFolders.updatedAt));
+  return rows.map(toFolder);
+}
+
+export async function createDashboardFolder(
+  name: string,
+  scope: DashboardFolderScope,
+  ctx: DashboardFolderContext,
+): Promise<DashboardFolderRecord> {
+  const trimmedName = name.trim();
+  if (!trimmedName) throw new Error("folder name is required");
+  if (scope === "shared" && !ctx.orgId) {
+    throw new Error("an active organization is required for shared folders");
+  }
+  const id = crypto.randomUUID();
+  const now = nowIso();
+  const folderOrgId = scope === "shared" ? ctx.orgId : null;
+  await (getDb() as any).insert(schema.dashboardFolders).values({
+    id,
+    name: trimmedName,
+    scope,
+    createdAt: now,
+    updatedAt: now,
+    ownerEmail: ctx.email,
+    orgId: folderOrgId,
+    visibility: scope === "shared" ? "org" : "private",
+  });
+  recordChange({
+    source: "dashboard-folders",
+    type: "change",
+    key: id,
+    ...(scope === "shared" && ctx.orgId
+      ? { orgId: ctx.orgId }
+      : { owner: ctx.email }),
+  });
+  return {
+    id,
+    name: trimmedName,
+    scope,
+    ownerEmail: ctx.email,
+    orgId: folderOrgId,
+    visibility: scope === "shared" ? "org" : "private",
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+async function getFolder(
+  id: string,
+  ctx: DashboardFolderContext,
+): Promise<DashboardFolderRecord> {
+  await assertAccess("dashboard-folder", id, "viewer", {
+    userEmail: ctx.email,
+    orgId: ctx.orgId ?? undefined,
+  });
+  const [row] = await (getDb() as any)
+    .select()
+    .from(schema.dashboardFolders)
+    .where(eq(schema.dashboardFolders.id, id))
+    .limit(1);
+  if (!row) throw new Error("dashboard folder not found");
+  return toFolder(row);
+}
+
+export async function assignDashboardToFolder(
+  dashboardId: string,
+  folderId: string | null,
+  ctx: DashboardFolderContext,
+): Promise<DashboardRecord> {
+  const dashboard = await getDashboard(dashboardId, ctx);
+  if (!dashboard) throw new Error("dashboard not found or inaccessible");
+  await assertAccess("dashboard", dashboardId, "editor", {
+    userEmail: ctx.email,
+    orgId: ctx.orgId ?? undefined,
+  });
+
+  if (folderId) {
+    const folder = await getFolder(folderId, ctx);
+    if (folder.scope === "personal") {
+      if (
+        dashboard.visibility !== "private" ||
+        dashboard.ownerEmail.toLowerCase() !== ctx.email.toLowerCase()
+      ) {
+        throw new Error("personal folders require an owned private dashboard");
+      }
+    } else if (
+      dashboard.visibility !== "org" ||
+      !ctx.orgId ||
+      dashboard.orgId !== ctx.orgId ||
+      folder.orgId !== ctx.orgId
+    ) {
+      throw new Error("shared folders require an org-visible dashboard");
+    }
+  }
+
+  await (getDb() as any)
+    .update(schema.dashboards)
+    .set({ folderId, updatedAt: nowIso(), updatedBy: ctx.email })
+    .where(eq(schema.dashboards.id, dashboardId));
+  recordChange({
+    source: "dashboards",
+    type: "change",
+    key: dashboardId,
+    ...((dashboard.visibility === "org" && dashboard.orgId
+      ? { orgId: dashboard.orgId }
+      : { owner: dashboard.ownerEmail }) as {
+      owner?: string;
+      orgId?: string;
+    }),
+  });
+  const updated = await getDashboard(dashboardId, ctx);
+  if (!updated) throw new Error("dashboard disappeared after folder update");
+  return updated;
+}

package/corpus/templates/analytics/server/lib/dashboard-panel-query.ts

@@ -1,6 +1,9 @@
 import type { CredentialContext } from "@agent-native/core/credentials";
 import { resolveCredential } from "@agent-native/core/credentials";
-import { runDataProgram } from "@agent-native/core/data-programs";
+import {
+  getInitializedDataProgramsAppId,
+  runDataProgram,
+} from "@agent-native/core/data-programs";
 import type { MissingKeyResponse } from "@agent-native/core/server";
 
 import { getUserSegmentation, queryEvents } from "./amplitude";
@@ -12,6 +15,7 @@ import {
   runPrometheusPanel,
   serializePanelDescriptorInput,
 } from "./prometheus";
+import { ANALYTICS_APP_ID } from "./provider-credentials";
 
 export const DASHBOARD_PANEL_SOURCES = [
   "bigquery",
@@ -25,8 +29,6 @@ export const DASHBOARD_PANEL_SOURCES = [
 
 export type DashboardPanelSource = (typeof DASHBOARD_PANEL_SOURCES)[number];
 
-const ANALYTICS_DATA_PROGRAM_APP_ID = "analytics";
-
 export interface DashboardPanelQueryResult {
   rows: Record<string, unknown>[];
   schema: { name: string; type: string }[];
@@ -360,7 +362,10 @@ async function runProgramPanel(
   const descriptor = parseProgramDescriptor(raw);
   const result = await runDataProgram({
     programId: descriptor.programId,
-    appId: ANALYTICS_DATA_PROGRAM_APP_ID,
+    // Use the same app scope that registered the agent's data-program actions.
+    // Standalone template dev can derive that scope from the runtime package
+    // even when APP_NAME is not explicitly set.
+    appId: getInitializedDataProgramsAppId() ?? ANALYTICS_APP_ID,
     params: descriptor.params,
     ctx: { userEmail: ctx.userEmail, orgId: ctx.orgId ?? null },
     triggeredBy: "panel_view",

package/corpus/templates/analytics/server/lib/dashboards-store.ts

@@ -28,7 +28,7 @@ import {
   resolveAccess,
   type ShareRole,
 } from "@agent-native/core/sharing";
-import { and, desc, eq, isNotNull, isNull, sql } from "drizzle-orm";
+import { and, desc, eq, inArray, isNotNull, isNull, sql } from "drizzle-orm";
 
 import { getDb, schema } from "../db/index.js";
 
@@ -62,10 +62,12 @@ export interface DashboardSummaryRecord {
   id: string;
   kind: DashboardKind;
   name: string;
+  description: string | null;
   configName: string | null;
   catalogTemplateId: string | null;
   demoId: string | null;
   parentId: string | null;
+  folderId: string | null;
   ownerEmail: string;
   orgId: string | null;
   visibility: "private" | "org" | "public";
@@ -76,6 +78,17 @@ export interface DashboardSummaryRecord {
   hiddenBy: string | null;
 }
 
+/** Hydrated dashboard row for catalog ranking only. */
+export interface DashboardCatalogRecord {
+  id: string;
+  kind: DashboardKind;
+  title: string;
+  description: string | null;
+  config: Record<string, unknown>;
+}
+
+const MAX_CATALOG_DASHBOARD_HYDRATION = 24;
+
 export interface DashboardRevisionRecord {
   id: string;
   dashboardId: string;
@@ -281,6 +294,13 @@ function rowToDashboardRevision(row: any): DashboardRevisionRecord {
   };
 }
 
+function configDescriptionFromValue(
+  value: Record<string, unknown>,
+): string | null {
+  const description = value["description"];
+  return typeof description === "string" ? description : null;
+}
+
 function configFromSettings(data: Record<string, unknown>): {
   title: string;
   config: Record<string, unknown>;
@@ -564,6 +584,11 @@ export async function listDashboardSummaries(
     : sql<
         string | null
       >`json_extract(${schema.dashboards.config}, '$.parentId')`;
+  const description = isPostgres()
+    ? sql<string | null>`(${schema.dashboards.config}::jsonb ->> 'description')`
+    : sql<
+        string | null
+      >`json_extract(${schema.dashboards.config}, '$.description')`;
   const configName = isPostgres()
     ? sql<string | null>`(${schema.dashboards.config}::jsonb ->> 'name')`
     : sql<string | null>`json_extract(${schema.dashboards.config}, '$.name')`;
@@ -586,10 +611,12 @@ export async function listDashboardSummaries(
       id: schema.dashboards.id,
       kind: schema.dashboards.kind,
       name: schema.dashboards.title,
+      description,
       ...(includeCatalogMetadata
         ? { configName, catalogTemplateId, demoId }
         : {}),
       parentId,
+      folderId: schema.dashboards.folderId,
       ownerEmail: schema.dashboards.ownerEmail,
       orgId: schema.dashboards.orgId,
       visibility: schema.dashboards.visibility,
@@ -603,11 +630,13 @@ export async function listDashboardSummaries(
     .where(where);
   const out: DashboardSummaryRecord[] = rows.map((row: any) => ({
     ...row,
+    description: typeof row.description === "string" ? row.description : null,
     configName: typeof row.configName === "string" ? row.configName : null,
     catalogTemplateId:
       typeof row.catalogTemplateId === "string" ? row.catalogTemplateId : null,
     demoId: typeof row.demoId === "string" ? row.demoId : null,
     parentId: typeof row.parentId === "string" ? row.parentId : null,
+    folderId: typeof row.folderId === "string" ? row.folderId : null,
     orgId: row.orgId ?? null,
     archivedAt: row.archivedAt ?? null,
     hiddenAt: row.hiddenAt ?? null,
@@ -656,8 +685,10 @@ export async function listDashboardSummaries(
         id,
         kind,
         name: title,
+        description: configDescriptionFromValue(config),
         ...catalogMetadata,
         parentId: typeof config.parentId === "string" ? config.parentId : null,
+        folderId: null,
         ownerEmail: ctx.email,
         orgId,
         visibility,
@@ -676,6 +707,90 @@ export async function listDashboardSummaries(
   return out;
 }
 
+/**
+ * Hydrate a bounded set of dashboard ids for catalog ranking.
+ *
+ * This is the catalog-specific path: it reads only the id, kind, title,
+ * description, and config needed for ranking, and only for explicit ids that
+ * were already shortlisted from the metadata path.
+ */
+export async function loadDashboardCatalogDashboards(
+  ctx: AccessCtx,
+  ids: readonly string[],
+  dbOverride?: any,
+): Promise<DashboardCatalogRecord[]> {
+  const db = (dbOverride ?? getDb()) as any;
+  const uniqueIds = [
+    ...new Set(ids.map((id) => id.trim()).filter(Boolean)),
+  ].slice(0, MAX_CATALOG_DASHBOARD_HYDRATION);
+  if (!uniqueIds.length) return [];
+
+  const description = isPostgres()
+    ? sql<string | null>`(${schema.dashboards.config}::jsonb ->> 'description')`
+    : sql<
+        string | null
+      >`json_extract(${schema.dashboards.config}, '$.description')`;
+  const archived = isNull(schema.dashboards.archivedAt);
+  const visible = isNull(schema.dashboards.hiddenAt);
+  const where = and(
+    accessFilter(schema.dashboards, schema.dashboardShares, {
+      userEmail: ctx.email,
+      orgId: ctx.orgId ?? undefined,
+    }),
+    inArray(schema.dashboards.id, uniqueIds),
+    archived,
+    visible,
+  );
+
+  // guard:allow-heavy-dashboard-list-read - bounded explicit ids shortlisted from metadata
+  const sqlRows = await db
+    .select({
+      id: schema.dashboards.id,
+      kind: schema.dashboards.kind,
+      title: schema.dashboards.title,
+      description,
+      config: schema.dashboards.config,
+    })
+    .from(schema.dashboards)
+    .where(where);
+
+  const byId = new Map<string, DashboardCatalogRecord>(
+    sqlRows.map((row: any) => {
+      const catalogRow: DashboardCatalogRecord = {
+        id: row.id,
+        kind: row.kind,
+        title: row.title,
+        description:
+          typeof row.description === "string" ? row.description : null,
+        config:
+          typeof row.config === "string" ? JSON.parse(row.config) : row.config,
+      };
+      return [row.id, catalogRow];
+    }),
+  );
+
+  const out: DashboardCatalogRecord[] = [];
+  for (const id of uniqueIds) {
+    const row = byId.get(id);
+    if (row) {
+      out.push(row);
+      continue;
+    }
+
+    const legacy = await findLegacyDashboard(id, ctx);
+    if (!legacy) continue;
+    const { title, config } = configFromSettings(legacy.data);
+    out.push({
+      id,
+      kind: legacy.kind,
+      title,
+      description: configDescriptionFromValue(config),
+      config,
+    });
+  }
+  return out;
+}
+
 /**
  * Reject a name that would collide with another dashboard visible to the
  * caller. Archived and hidden dashboards are intentionally excluded because

package/corpus/templates/analytics/server/lib/first-party-analytics-rollups.ts

@@ -2,10 +2,7 @@ import { isPostgres } from "@agent-native/core/db";
 import { sql } from "@agent-native/core/db/schema";
 
 import { getDb, schema } from "../db/index.js";
-import {
-  FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_KEY,
-  FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_SQL,
-} from "./analytics-rollup-lock.js";
+import { FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_KEY } from "./analytics-rollup-lock.js";
 
 /**
  * The normalized subset emitted by first-party analytics ingest. Keeping this
@@ -151,10 +148,9 @@ export async function upsertFirstPartyAnalyticsRollups(
       // snapshot. Holding it through ingest's rollup increment prevents the
       // backfill's monotonic upsert from losing a concurrently committed
       // event.
-      await tx.execute({
-        sql: FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_SQL,
-        args: [FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_KEY],
-      });
+      await tx.execute(
+        sql`SELECT pg_advisory_xact_lock(hashtextextended(${FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_KEY}, 0::bigint))`,
+      );
     }
     const dailyRows = [...dailyRollups.values()];
     await tx

package/corpus/templates/analytics/server/lib/first-party-analytics.ts

@@ -1,6 +1,6 @@
 import { getDbExec } from "@agent-native/core/db";
 import { runWithRequestContext } from "@agent-native/core/server";
-import { and, eq, isNull, or } from "drizzle-orm";
+import { and, eq, isNull, lt, or } from "drizzle-orm";
 
 import { FIRST_PARTY_ANALYTICS_QUERY_TIMEOUT_MS } from "../../shared/dashboard-report-timeouts.js";
 import { getDb, schema } from "../db/index.js";
@@ -181,6 +181,68 @@ export async function listAnalyticsPublicKeys(
   }));
 }
 
+/** How stale the last-used stamp must be before a request pays to refresh it. */
+const LAST_USED_AT_REFRESH_MS = 60_000;
+
+/**
+ * Refresh a public key's last-used stamp without serializing ingest behind it.
+ *
+ * This UPDATE used to sit inside the ingest transaction, so every concurrent
+ * request for one public key took an exclusive row lock on that key's row and
+ * held it until the transaction committed — which meant through the rollup
+ * upsert. Production stacked 36 writers on three hot rows waiting 38-57s each;
+ * that exhausted the connection pool, and the whole app stopped loading while
+ * Postgres reported "no server connection available, client being queued". The
+ * stamp is bookkeeping: it needs neither atomicity with the events nor
+ * second-precision, and losing one is harmless.
+ *
+ * The staleness predicate throttles in SQL rather than in the caller, because
+ * Postgres only locks rows an UPDATE actually matches — a request whose key was
+ * stamped seconds ago matches nothing and takes no lock at all. Doing the same
+ * check in JS would reintroduce the convoy, since every racing request would
+ * still issue its own unconditional write.
+ *
+ * `last_used_at` is TEXT holding ISO-8601 UTC (always `Z`-suffixed), so `lt` is
+ * a lexicographic comparison that happens to be chronological. Storing a local
+ * or offset-bearing timestamp here would silently break this ordering.
+ */
+export async function touchPublicKeyLastUsedAt(
+  keyId: string,
+  receivedAt: string,
+): Promise<void> {
+  const parsed = Date.parse(receivedAt);
+  if (!Number.isFinite(parsed)) {
+    console.warn(
+      "[first-party-analytics] Skipping last-used stamp: unparseable receivedAt",
+      receivedAt,
+    );
+    return;
+  }
+  const staleBefore = new Date(parsed - LAST_USED_AT_REFRESH_MS).toISOString();
+  try {
+    const db = await getDb();
+    await db
+      .update(schema.analyticsPublicKeys)
+      .set({ lastUsedAt: receivedAt })
+      .where(
+        and(
+          eq(schema.analyticsPublicKeys.id, keyId),
+          or(
+            isNull(schema.analyticsPublicKeys.lastUsedAt),
+            lt(schema.analyticsPublicKeys.lastUsedAt, staleBefore),
+          ),
+        ),
+      );
+  } catch (error) {
+    // Best-effort by design: a failed stamp must not reject an ingest whose
+    // events already committed. Loud enough to see if it starts failing always.
+    console.warn(
+      "[first-party-analytics] Failed to refresh key last-used stamp:",
+      error,
+    );
+  }
+}
+
 function parseReplayAllowedOrigins(value: unknown): string[] {
   if (Array.isArray(value)) {
     return value.filter((item): item is string => typeof item === "string");
@@ -539,18 +601,11 @@ export async function recordAnalyticsEvents(
   if (rows.length && backend.sink !== "bigquery") {
     await db.transaction(async (tx: any) => {
       await tx.insert(schema.analyticsEvents).values(rows);
-      await tx
-        .update(schema.analyticsPublicKeys)
-        .set({ lastUsedAt: receivedAt })
-        .where(eq(schema.analyticsPublicKeys.id, key.id));
       await upsertFirstPartyAnalyticsRollups(rows, tx);
     });
   }
-  if (rows.length && backend.sink === "bigquery") {
-    await db
-      .update(schema.analyticsPublicKeys)
-      .set({ lastUsedAt: receivedAt })
-      .where(eq(schema.analyticsPublicKeys.id, key.id));
+  if (rows.length) {
+    await touchPublicKeyLastUsedAt(key.id, receivedAt);
   }
 
   // Fork captured exceptions into the dedicated error-capture tables. This is