@agent-native/core 0.77.24 → 0.78.1

package/corpus/templates/analytics/server/handlers/sql-query.ts

@@ -1,255 +1,12 @@
 import { readBody } from "@agent-native/core/server";
 import { defineEventHandler, setResponseStatus } from "h3";
 
-import { getUserSegmentation, queryEvents } from "../lib/amplitude";
-import { runQuery } from "../lib/bigquery";
+import { runApiHandlerWithContext } from "../lib/credentials";
 import {
-  requireCredential,
-  runApiHandlerWithContext,
-} from "../lib/credentials";
-import { runDemoPanel, serializeDemoDescriptorInput } from "../lib/demo-source";
-import { queryFirstPartyAnalytics } from "../lib/first-party-analytics";
-import { runReport } from "../lib/google-analytics";
-import {
-  runPrometheusPanel,
-  serializePanelDescriptorInput,
-} from "../lib/prometheus";
-
-/**
- * ga4 panels carry a JSON blob in `sql` describing the GA4 Data API call.
- * Shape: { metrics: string[]; dimensions?: string[]; days?: number;
- *          startDate?: string; endDate?: string }. Dates are resolved from
- * `days` when startDate/endDate are omitted so seeded dashboards can use
- * the simpler `{"days": 30}` form.
- */
-async function runGa4Panel(raw: string): Promise<{
-  rows: Record<string, unknown>[];
-  schema: { name: string; type: string }[];
-}> {
-  let parsed: {
-    metrics?: unknown;
-    dimensions?: unknown;
-    days?: unknown;
-    startDate?: unknown;
-    endDate?: unknown;
-    filter?: unknown;
-  };
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err: any) {
-    throw new Error(
-      `ga4 panel sql must be a JSON object with metrics/dimensions/days: ${err?.message ?? err}`,
-    );
-  }
-  if (!parsed || typeof parsed !== "object") {
-    throw new Error("ga4 panel sql must be a JSON object");
-  }
-  const metrics = Array.isArray(parsed.metrics)
-    ? parsed.metrics.filter((m): m is string => typeof m === "string")
-    : [];
-  if (metrics.length === 0) {
-    throw new Error("ga4 panel requires at least one metric");
-  }
-  const dimensions = Array.isArray(parsed.dimensions)
-    ? parsed.dimensions.filter((d): d is string => typeof d === "string")
-    : [];
-  const days =
-    typeof parsed.days === "number" ? parsed.days : Number(parsed.days);
-  const startDate =
-    typeof parsed.startDate === "string" && parsed.startDate
-      ? parsed.startDate
-      : Number.isFinite(days) && days > 0
-        ? `${days}daysAgo`
-        : "7daysAgo";
-  const endDate =
-    typeof parsed.endDate === "string" && parsed.endDate
-      ? parsed.endDate
-      : "today";
-
-  const dimensionFilter =
-    parsed.filter && typeof parsed.filter === "object"
-      ? (parsed.filter as Record<string, unknown>)
-      : undefined;
-
-  const report = await runReport(
-    dimensions,
-    metrics,
-    { startDate, endDate },
-    dimensionFilter,
-  );
-
-  // Flatten each GA4 row to { dimensionName: value, metricName: value } so
-  // downstream chart renderers treat it identically to SQL rows. Metrics are
-  // parsed to numbers since every chart type (metric card, bar, line, table)
-  // relies on numeric typing for y-axis detection.
-  const rows: Record<string, unknown>[] = (report.rows ?? []).map((row) => {
-    const out: Record<string, unknown> = {};
-    dimensions.forEach((name, i) => {
-      out[name] = row.dimensionValues?.[i]?.value ?? "";
-    });
-    metrics.forEach((name, i) => {
-      const raw = row.metricValues?.[i]?.value ?? "0";
-      const num = Number(raw);
-      out[name] = Number.isFinite(num) ? num : raw;
-    });
-    return out;
-  });
-
-  const schema = [
-    ...dimensions.map((name) => ({ name, type: "string" })),
-    ...metrics.map((name) => ({ name, type: "number" })),
-  ];
-  return { rows, schema };
-}
-
-/**
- * Amplitude panels carry a JSON blob in `sql` describing the segmentation
- * API call. Shape: { event: string; metric?: "totals"|"uniques";
- * groupBy?: string; days?: number; startDate?: string; endDate?: string }.
- */
-async function runAmplitudePanel(raw: string): Promise<{
-  rows: Record<string, unknown>[];
-  schema: { name: string; type: string }[];
-}> {
-  let parsed: {
-    event?: unknown;
-    metric?: unknown;
-    groupBy?: unknown;
-    days?: unknown;
-    startDate?: unknown;
-    endDate?: unknown;
-  };
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err: any) {
-    throw new Error(
-      `amplitude panel sql must be a JSON object: ${err?.message ?? err}`,
-    );
-  }
-  if (!parsed || typeof parsed !== "object") {
-    throw new Error("amplitude panel sql must be a JSON object");
-  }
-  if (typeof parsed.event !== "string" || !parsed.event.trim()) {
-    throw new Error("amplitude panel requires an 'event' field");
-  }
-
-  const eventType = parsed.event.trim();
-  const groupBy =
-    typeof parsed.groupBy === "string" ? parsed.groupBy : undefined;
-
-  const days =
-    typeof parsed.days === "number" ? parsed.days : Number(parsed.days);
-  const now = new Date();
-  const startDate =
-    Number.isFinite(days) && days > 0
-      ? new Date(now.getTime() - days * 86_400_000)
-      : new Date(now.getTime() - 30 * 86_400_000);
-
-  const fmt = (d: Date) => d.toISOString().slice(0, 10).replace(/-/g, "");
-  const startStr =
-    typeof parsed.startDate === "string" && parsed.startDate
-      ? parsed.startDate.replace(/-/g, "")
-      : fmt(startDate);
-  const endStr =
-    typeof parsed.endDate === "string" && parsed.endDate
-      ? parsed.endDate.replace(/-/g, "")
-      : fmt(now);
-
-  const response = groupBy
-    ? await getUserSegmentation(eventType, startStr, endStr, groupBy)
-    : await queryEvents(eventType, startStr, endStr);
-
-  return flattenAmplitudeResponse(response, groupBy);
-}
-
-function flattenAmplitudeResponse(
-  response: unknown,
-  groupBy?: string,
-): {
-  rows: Record<string, unknown>[];
-  schema: { name: string; type: string }[];
-} {
-  const data = (response as any)?.data;
-  if (!data) return { rows: [], schema: [] };
-
-  const xValues: string[] = Array.isArray(data.xValues) ? data.xValues : [];
-  const series = data.series;
-
-  if (!series || (Array.isArray(series) && series.length === 0)) {
-    return { rows: [], schema: [] };
-  }
-
-  // Normalize YYYYMMDD xValues → YYYY-MM-DD for chart rendering
-  const normDate = (d: string) =>
-    /^\d{8}$/.test(d)
-      ? `${d.slice(0, 4)}-${d.slice(4, 6)}-${d.slice(6, 8)}`
-      : d;
-
-  if (!groupBy) {
-    // No grouping — time series. series is [[n1, n2, ...]] or [{date: {value:n}}, ...]
-    const firstSeries = Array.isArray(series) ? series[0] : series;
-    const rows: Record<string, unknown>[] = xValues.map((dateStr, i) => {
-      let count = 0;
-      if (Array.isArray(firstSeries)) {
-        count = typeof firstSeries[i] === "number" ? firstSeries[i] : 0;
-      } else if (firstSeries && typeof firstSeries === "object") {
-        const entry = (firstSeries as Record<string, any>)[dateStr];
-        count = entry?.value ?? 0;
-      }
-      return { date: normDate(dateStr), count };
-    });
-    return {
-      rows,
-      schema: [
-        { name: "date", type: "string" },
-        { name: "count", type: "number" },
-      ],
-    };
-  }
-
-  // With groupBy — aggregate each series across dates into one row per group
-  const seriesLabels: unknown[] = Array.isArray(data.seriesLabels)
-    ? data.seriesLabels
-    : [];
-  const rows: Record<string, unknown>[] = [];
-
-  if (Array.isArray(series)) {
-    for (let i = 0; i < series.length; i++) {
-      const s = series[i];
-      let label = `Group ${i}`;
-      if (seriesLabels[i]) {
-        const entry = seriesLabels[i];
-        if (Array.isArray(entry) && entry.length >= 2) {
-          label = String(entry[entry.length - 1]);
-        } else {
-          label = String(entry);
-        }
-      }
-
-      let total = 0;
-      if (Array.isArray(s)) {
-        for (const n of s) total += typeof n === "number" ? n : 0;
-      } else if (s && typeof s === "object") {
-        for (const val of Object.values(s as Record<string, any>)) {
-          total += val?.value ?? (typeof val === "number" ? val : 0);
-        }
-      }
-
-      rows.push({ [groupBy]: label, count: total });
-    }
-  }
-
-  // Sort descending by count
-  rows.sort((a, b) => (b.count as number) - (a.count as number));
-
-  return {
-    rows,
-    schema: [
-      { name: groupBy, type: "string" },
-      { name: "count", type: "number" },
-    ],
-  };
-}
+  isDashboardPanelSource,
+  normalizeDashboardPanelQuery,
+  runDashboardPanelQuery,
+} from "../lib/dashboard-panel-query";
 
 export const handleSqlQuery = defineEventHandler(async (event) => {
   return runApiHandlerWithContext(event, async (ctx) => {
@@ -258,17 +15,7 @@ export const handleSqlQuery = defineEventHandler(async (event) => {
       source?: unknown;
     };
 
-    if (
-      typeof source !== "string" ||
-      ![
-        "bigquery",
-        "ga4",
-        "amplitude",
-        "first-party",
-        "demo",
-        "prometheus",
-      ].includes(source)
-    ) {
+    if (!isDashboardPanelSource(source)) {
       setResponseStatus(event, 400);
       return {
         error:
@@ -276,96 +23,9 @@ export const handleSqlQuery = defineEventHandler(async (event) => {
       };
     }
 
-    let query: string;
-    if (source === "prometheus" || source === "demo") {
-      if (rawQuery === undefined || rawQuery === null || rawQuery === "") {
-        setResponseStatus(event, 400);
-        return { error: "Missing or invalid query" };
-      }
-      try {
-        query =
-          source === "demo"
-            ? serializeDemoDescriptorInput(rawQuery)
-            : serializePanelDescriptorInput(rawQuery);
-      } catch (err: any) {
-        setResponseStatus(event, 400);
-        return { error: err?.message || "Missing or invalid query" };
-      }
-    } else {
-      if (!rawQuery || typeof rawQuery !== "string") {
-        setResponseStatus(event, 400);
-        return { error: "Missing or invalid query" };
-      }
-      query = rawQuery;
-    }
-
     try {
-      if (source === "bigquery") {
-        const missing = await requireCredential(
-          event,
-          "BIGQUERY_PROJECT_ID",
-          "BigQuery",
-        );
-        if (missing) return missing;
-        const result = await runQuery(query);
-        return result;
-      }
-
-      if (source === "ga4") {
-        const missingProp = await requireCredential(
-          event,
-          "GA4_PROPERTY_ID",
-          "Google Analytics",
-        );
-        if (missingProp) return missingProp;
-        const missingCreds = await requireCredential(
-          event,
-          "GOOGLE_APPLICATION_CREDENTIALS_JSON",
-          "Google Analytics",
-        );
-        if (missingCreds) return missingCreds;
-        return await runGa4Panel(query);
-      }
-
-      if (source === "amplitude") {
-        const missingKey = await requireCredential(
-          event,
-          "AMPLITUDE_API_KEY",
-          "Amplitude",
-        );
-        if (missingKey) return missingKey;
-        const missingSecret = await requireCredential(
-          event,
-          "AMPLITUDE_SECRET_KEY",
-          "Amplitude",
-        );
-        if (missingSecret) return missingSecret;
-        return await runAmplitudePanel(query);
-      }
-
-      if (source === "first-party") {
-        return await queryFirstPartyAnalytics(query, {
-          userEmail: ctx.userEmail,
-          orgId: ctx.orgId ?? null,
-        });
-      }
-
-      if (source === "demo") {
-        return await runDemoPanel(query);
-      }
-
-      if (source === "prometheus") {
-        const missingUrl = await requireCredential(
-          event,
-          "PROMETHEUS_URL",
-          "Prometheus",
-        );
-        if (missingUrl) return missingUrl;
-        return await runPrometheusPanel(query);
-      }
-
-      setResponseStatus(event, 400);
-      return { error: "Unsupported source" };
+      const query = normalizeDashboardPanelQuery(source, rawQuery);
+      return await runDashboardPanelQuery({ source, query, ctx });
     } catch (error: any) {
       const message = error?.message || String(error);
       console.error(`SQL query error (${source}):`, message);

package/corpus/templates/analytics/server/jobs/dashboard-report.ts

@@ -0,0 +1,66 @@
+import { runWithRequestContext } from "@agent-native/core/server/request-context";
+
+import { sendDashboardReportSubscription } from "../lib/dashboard-report";
+import {
+  claimDueDashboardReportSubscriptions,
+  markDashboardReportResult,
+} from "../lib/dashboard-report-subscriptions";
+
+let running = false;
+const DEFAULT_MAX_REPORTS_PER_SWEEP = 5;
+
+function maxReportsPerSweep(): number {
+  const raw = process.env.DASHBOARD_REPORT_SWEEP_LIMIT?.trim();
+  if (!raw) return DEFAULT_MAX_REPORTS_PER_SWEEP;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0
+    ? parsed
+    : DEFAULT_MAX_REPORTS_PER_SWEEP;
+}
+
+/**
+ * Run one dashboard report sweep. Exported for deployment-specific scheduled
+ * functions that should not rely on a long-lived Node process.
+ */
+export async function runDashboardReportsOnce(): Promise<{
+  processed: number;
+  failed: number;
+  remaining: number;
+}> {
+  if (running) return { processed: 0, failed: 0, remaining: 0 };
+  running = true;
+  let processed = 0;
+  let failed = 0;
+  let remaining = 0;
+
+  try {
+    const sweepLimit = maxReportsPerSweep();
+    const batch = await claimDueDashboardReportSubscriptions(sweepLimit);
+    remaining = batch.length >= sweepLimit ? 1 : 0;
+    for (const sub of batch) {
+      processed++;
+      try {
+        await runWithRequestContext(
+          {
+            userEmail: sub.ownerEmail,
+            orgId: sub.orgId ?? undefined,
+          },
+          () => sendDashboardReportSubscription(sub),
+        );
+        await markDashboardReportResult(sub, "success");
+      } catch (err: any) {
+        failed++;
+        const message = err?.message ?? String(err);
+        console.error(
+          `[dashboard-report] Subscription ${sub.id} failed:`,
+          message,
+        );
+        await markDashboardReportResult(sub, "error", message);
+      }
+    }
+  } finally {
+    running = false;
+  }
+
+  return { processed, failed, remaining };
+}

package/corpus/templates/analytics/server/jobs/session-replay-retention.ts

@@ -0,0 +1,29 @@
+import { runSessionReplayRetentionSweep } from "../lib/session-replay";
+
+let running = false;
+
+/**
+ * Run one session replay retention sweep. Exported for deployment-specific
+ * scheduled functions that should not rely on a long-lived Node process.
+ */
+export async function runSessionReplayRetentionOnce(): Promise<{
+  finalized: number;
+  expired: number;
+  chunks: number;
+  blobDeleteFailures: number;
+}> {
+  if (running) {
+    return {
+      finalized: 0,
+      expired: 0,
+      chunks: 0,
+      blobDeleteFailures: 0,
+    };
+  }
+  running = true;
+  try {
+    return await runSessionReplayRetentionSweep();
+  } finally {
+    running = false;
+  }
+}