@agent-native/core-corpus 0.210.2 → 0.211.0

package/corpus/templates/analytics/app/components/layout/Sidebar.tsx

@@ -2450,7 +2450,7 @@ export function Sidebar({ mobile }: { mobile?: boolean } = {}) {
             collapsed={true}
           />
           <nav className="flex min-h-0 flex-1 flex-col items-center overflow-y-auto px-2 py-3">
-            <div className="my-auto flex flex-col items-center gap-2">
+            <div className="flex flex-col items-center gap-3">
               {collapsedNavItems.map((item) => {
                 const Icon = item.icon;
                 return (

package/corpus/templates/analytics/app/i18n/en-US.ts

@@ -321,65 +321,19 @@ export default {
     sigmaRetryConnection: "Check the connection and try again.",
     sigmaRetry: "Retry",
     sigmaNoWorkbooks: "No Sigma workbooks are available.",
-    sigmaWorkbook: "Workbook",
-    sigmaChooseWorkbook: "Choose a workbook",
-    sigmaStatusNotImported: "Not imported",
-    sigmaStatusImporting: "Importing",
-    sigmaStatusImported: "Imported",
-    sigmaStatusFailed: "Import failed",
+    sigmaSearchWorkbooks: "Search workbooks…",
+    sigmaNoMatchingWorkbooks: "No matching workbooks",
+    sigmaNoMatchingWorkbooksLoadMore:
+      "No matching workbooks loaded yet. Load more workbooks to search the rest.",
+    sigmaOpenMigratedDashboard: "Open the imported dashboard in a new tab",
+    sigmaOwnedBy: "Owned by",
+    sigmaMigratingTooltip: "Being migrated by {{name}}",
+    sigmaMigrate: "Migrate",
+    sigmaMigrateComingSoon: "Coming soon",
     sigmaArchived: "Archived",
-    sigmaPreviewTitle: "Workbook contents",
-    sigmaPreviewFailed: "Couldn't preview this workbook",
-    sigmaRetryPreview: "Try again to load the workbook preview.",
-    sigmaImportableCount: "{{count}} importable",
-    sigmaUnsupportedCount: "{{count}} unsupported",
-    sigmaImportable: "Importable",
-    sigmaUnsupported: "Unsupported",
-    sigmaNoElements: "No workbook elements were found.",
-    sigmaPreviewOnly:
-      "Preview only for now: Sigma does not expose a BigQuery project mapping Analytics can verify, so importing is disabled until that mapping is available.",
-    sigmaPreviewTruncated: "Showing {{shown}} of {{total}} elements.",
-    sigmaImportWorkbook: "Import workbook",
-    sigmaImporting: "Importing workbook…",
-    sigmaImportInProgress:
-      "An import for this workbook is already in progress.",
-    sigmaMigrationFailed: "Couldn't import this workbook. Try again.",
-    sigmaMigrationResultInvalid:
-      "The import response was incomplete. Reload the workbook list to check its status.",
-    sigmaImportComplete: "Dashboard created",
-    sigmaImportSummary:
-      "{{imported}} elements imported; {{unsupported}} unsupported elements retained as review callouts.",
-    sigmaAlreadyImported: "This workbook has already been imported.",
-    sigmaImportedNoDashboard:
-      "The imported dashboard isn't available to open from this account.",
-    sigmaReviewRequiredCount: "{{count}} need review",
-    sigmaBetaRepresentationWarning:
-      "This beta import may represent some visualizations differently from Sigma.",
-    sigmaReasonUnsupportedElement:
-      "This element type is not supported for import.",
-    sigmaReasonUnsupportedSource:
-      "This element uses a source that is not supported for import.",
-    sigmaReasonSourceMappingRequired:
-      "Sigma doesn't expose a BigQuery project mapping Analytics can verify, so this SQL can't be imported yet.",
-    sigmaReasonSourceUnavailable:
-      "Sigma didn't allow access to this source connection. Check its permissions.",
-    sigmaReasonQueryUnavailable:
-      "Sigma did not return an importable query for this element.",
-    sigmaReasonUnsafeSql: "This query pattern cannot be imported safely.",
-    sigmaReasonVisualizationReview:
-      "The data can be imported, but verify its visualization after import.",
-    sigmaRetryOwnerOnly:
-      "Only the person who started this import can retry it.",
-    sigmaImportedByTeammate: "Imported by a teammate",
-    sigmaFlaggedCount: "{{count}} flagged for review",
     sigmaMoreWorkbooksFailed: "Could not load more workbooks",
     sigmaLoadingMore: "Loading workbooks…",
     sigmaLoadMore: "Load more workbooks",
-    sigmaOpenDashboard: "Open dashboard",
-    sigmaReviewWithAgent: "Review with agent",
-    sigmaReviewContext: "Imported Sigma dashboard",
-    sigmaReviewPrompt:
-      "Review the imported Sigma dashboard {{name}}. Check the imported panels and unsupported elements, then suggest any corrections.",
   },
   sidebar: {
     collapseSidebar: "Collapse sidebar",
@@ -938,6 +892,13 @@ export default {
     viewOnly: "You have view-only access to this dashboard.",
     saveFailed: "Couldn't save dashboard",
     saveFailedWithMessage: "Couldn't save dashboard: {{message}}",
+    panelCostTitle: 'BigQuery cost of "{{title}}"',
+    panelCostOverTitle: '"{{title}}" is expensive to refresh',
+    panelCostScheduled:
+      "~{{size}} scanned · {{perRun}} per refresh · ~{{perMonth}}/month in email reports",
+    panelCostUnscheduled:
+      "~{{size}} scanned · {{perRun}} per refresh · no email reports",
+    panelCostOverHint: "A narrower date range or fewer columns scans less.",
     archived: 'Archived "{{name}}"',
     unhid: 'Unhid "{{name}}"',
     archiveFailed: "Couldn't archive dashboard",
@@ -1314,6 +1275,44 @@ export default {
       "Couldn't check for existing entries with this metric.",
   },
   dataSources: {
+    searchConsole: {
+      name: "Google Search Console",
+      description:
+        "Daily clicks and impressions per page for the Content view.",
+      serviceAccount: "Service account",
+      copyEmail: "Copy email",
+      grantHint:
+        "Add this email as a user on each property in Search Console, under Settings → Users and permissions.",
+      noServiceAccount: "Add a Google service account key first.",
+      openGoogleCloud: "Open Google Cloud",
+      invalidServiceAccount: "The saved service account key can't be read.",
+      properties: "Properties",
+      siteLabel: "Property",
+      pathLabel: "Path prefix",
+      pathInvalid: "Start the path prefix with /.",
+      addProperty: "Add property",
+      removeProperty: "Remove property",
+      save: "Save",
+      collectDaily: "Collect daily",
+      adminOnly: "Only organization owners and admins can change this.",
+      statusCollecting: "Collecting",
+      statusNeedsAccess: "Needs access",
+      statusFailed: "Last run failed",
+      runSucceeded: "Collected {{when}}",
+      runNeedsAccess: "No access as of {{when}}",
+      runRunning: "Collecting since {{when}}",
+      runFailed: "Failed {{when}}",
+      unavailable: "Collection status is unavailable: {{message}}",
+      keyUnreadable:
+        "Couldn't read the saved service account key. Re-save it under Google Cloud.",
+      propertyBareDomain: "For a Domain property, use {{suggestion}}.",
+      propertyInvalidDomain:
+        "Put only the domain after sc-domain:, as in {{suggestion}}.",
+      propertyMissingSlash:
+        "URL-prefix properties end in /. Use {{suggestion}}.",
+      propertyUnrecognized:
+        "Use sc-domain:example.com, or a URL-prefix property ending in /.",
+    },
     uploadFile: "Upload file",
     googleSheetsExport: "Google Sheets export",
     googleSheetsExportDescription:

package/corpus/templates/analytics/app/pages/DashboardOverview.tsx

@@ -432,7 +432,6 @@ export default function DashboardOverview() {
             setSigmaMigrationOpen(open);
             if (!open) setPreferredSigmaConnectionId(null);
           }}
-          onImported={() => void dashboardsQuery.refetch()}
         />
       ) : null}
 

package/corpus/templates/analytics/app/pages/DataSources.tsx

@@ -116,6 +116,11 @@ import {
   type DataSourceCategory,
   type WalkthroughStep,
 } from "@/lib/data-sources";
+import {
+  SearchConsoleDetail,
+  searchConsoleState,
+  useContentCollectionStatus,
+} from "@/pages/data-sources/SearchConsoleDetail";
 
 import {
   ConnectionTestStatus,
@@ -2214,6 +2219,7 @@ export default function DataSources() {
       statusData.workspaceConnections?.available === false);
 
   const firstParty = useFirstPartyAnalyticsData();
+  const contentCollection = useContentCollectionStatus();
   const googleSheetsConnected =
     getGoogleSheetsConnection(statusData)?.grantState === "connected";
 
@@ -2377,6 +2383,55 @@ export default function DataSources() {
     ),
   };
 
+  const searchConsoleLabel = {
+    unavailable: {
+      label: t("dataSources.statusUnknown"),
+      className: "text-destructive",
+    },
+    collecting: {
+      label: t("dataSources.searchConsole.statusCollecting"),
+      className: "text-emerald-500",
+    },
+    needs_access: {
+      label: t("dataSources.searchConsole.statusNeedsAccess"),
+      className: "text-amber-600 dark:text-amber-400",
+    },
+    failed: {
+      label: t("dataSources.searchConsole.statusFailed"),
+      className: "text-destructive",
+    },
+    off: {
+      label: t("dataSources.notConfigured"),
+      className: "text-muted-foreground",
+    },
+  }[searchConsoleState(contentCollection.data, contentCollection.error)];
+  const searchConsoleEntry: SourceEntry = {
+    id: "google-search-console",
+    name: t("dataSources.searchConsole.name"),
+    description: t("dataSources.searchConsole.description"),
+    category: "seo",
+    logo: (
+      <SourceLogo
+        id="google-search-console"
+        name={t("dataSources.searchConsole.name")}
+        fallbackIcon={IconSearch}
+      />
+    ),
+    status: contentCollection.isLoading ? undefined : searchConsoleLabel.label,
+    statusClassName: searchConsoleLabel.className,
+    connected:
+      searchConsoleState(contentCollection.data, contentCollection.error) ===
+      "collecting",
+    searchText: [
+      t("dataSources.searchConsole.name"),
+      t("dataSources.searchConsole.description"),
+      "google search console gsc seo clicks impressions",
+    ]
+      .join(" ")
+      .toLowerCase(),
+    detail: <SearchConsoleDetail />,
+  };
+
   const customApiEntry: SourceEntry = {
     id: "custom-api",
     name: t("dataSources.customApi.title"),
@@ -2403,6 +2458,7 @@ export default function DataSources() {
     firstPartyEntry,
     ...sourceEntries,
     googleSheetsEntry,
+    searchConsoleEntry,
     customApiEntry,
   ];
   const activeEntry = entries.find((entry) => entry.id === activeId);

package/corpus/templates/analytics/app/pages/adhoc/sql-dashboard/filter-vars.ts

@@ -52,7 +52,8 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-export const MAX_FILTER_OPTIONS = 100;
+export const MAX_FILTER_OPTIONS = 500;
+export const MAX_FILTER_PRESET_VALUES = 100;
 // Each preset is a button in the dropdown, so a filter offers a short list.
 export const MAX_FILTER_PRESETS = 20;
 
@@ -110,9 +111,9 @@ export function filterPresetIssues(
     if (
       isRecord(preset) &&
       Array.isArray(preset.values) &&
-      preset.values.length > MAX_FILTER_OPTIONS
+      preset.values.length > MAX_FILTER_PRESET_VALUES
     ) {
-      return `has more than ${MAX_FILTER_OPTIONS} values`;
+      return `has more than ${MAX_FILTER_PRESET_VALUES} values`;
     }
     if (
       !isFilterPreset(preset) ||

package/corpus/templates/analytics/app/pages/adhoc/sql-dashboard/index.tsx

@@ -208,6 +208,7 @@ import {
   type FetchedDashboard,
 } from "./fetch-dashboard";
 import { interpolate, interpolateDashboardPanelSql } from "./interpolate";
+import { panelCostChange, usePanelCostNotice } from "./panel-cost-notice";
 import { serializePanelSql } from "./panel-sql";
 import { AddPanelPopover, PanelEditorDialog } from "./PanelEditorDialog";
 import { listReportablePanelIds } from "./report-panel-window";
@@ -1190,6 +1191,7 @@ function SqlDashboardPageContent({
     otherViewers: otherViewerCount(activeUsers, session?.email),
     onUndo: undoLatestSave,
   });
+  const panelCost = usePanelCostNotice(dashboardId);
 
   const updateCachedDashboardConfig = useCallback(
     (updated: SqlDashboardConfig) => {
@@ -2039,8 +2041,10 @@ function SqlDashboardPageContent({
           clampDashboardColumns(current.columns ?? DEFAULT_DASHBOARD_COLUMNS),
         ),
       }));
+      // A removed panel's cost notice would outlive it.
+      panelCost.clear(panelId);
     },
-    [persist],
+    [panelCost, persist],
   );
 
   const handleResizePanel = useCallback(
@@ -2073,6 +2077,7 @@ function SqlDashboardPageContent({
   );
   const handleSavePanel = useCallback(
     async (panel: SqlPanel, editorBaseline?: SqlPanel | null) => {
+      const cost: { change?: ReturnType<typeof panelCostChange> } = {};
       await persistThrow((current) => {
         const idx = current.panels.findIndex((p) => p.id === panel.id);
         if (editorBaseline && idx < 0) {
@@ -2086,30 +2091,43 @@ function SqlDashboardPageContent({
                 current.panels[idx],
               )
             : panel;
+        cost.change = panelCostChange(
+          idx >= 0 ? current.panels[idx] : null,
+          nextPanel,
+        );
         const nextPanels =
           idx >= 0
             ? current.panels.map((p, i) => (i === idx ? nextPanel : p))
             : [...current.panels, nextPanel];
         return { ...current, panels: nextPanels };
       });
+      if (cost.change === "notify")
+        void panelCost.notify(panel.id, panel.title);
+      // A panel turned into a section no longer costs what its notice said.
+      if (cost.change === "clear") panelCost.clear(panel.id);
     },
-    [persistThrow],
+    [panelCost, persistThrow],
   );
   const handleSaveSql = useCallback(
     async (panelId: string, sql: string) => {
+      const edit: { title?: string } = {};
       await persistThrow((current) => {
-        if (!current.panels.some((panel) => panel.id === panelId)) {
-          return current;
-        }
+        const panel = current.panels.find((p) => p.id === panelId);
+        edit.title =
+          panel && serializePanelSql(panel.sql) !== serializePanelSql(sql)
+            ? panel.title
+            : undefined;
+        if (!panel) return current;
         return {
           ...current,
-          panels: current.panels.map((panel) =>
-            panel.id === panelId ? { ...panel, sql } : panel,
+          panels: current.panels.map((p) =>
+            p.id === panelId ? { ...p, sql } : p,
           ),
         };
       });
+      if (edit.title !== undefined) void panelCost.notify(panelId, edit.title);
     },
-    [persistThrow],
+    [panelCost, persistThrow],
   );
   const handleSaveEditedPanel = useCallback(
     async (panel: SqlPanel) => {

package/corpus/templates/analytics/app/pages/adhoc/sql-dashboard/interpolate.ts

@@ -158,7 +158,9 @@ export function interpolate(
         return "SELECT __invalid_custom_date_range__";
       }
       if (
-        /generate_series|generate_date_array/i.test(sourceSql) &&
+        /generate_series|generate_date_array|\bwith\s+recursive\b/i.test(
+          sourceSql,
+        ) &&
         (Date.parse(`${end}T00:00:00.000Z`) -
           Date.parse(`${start}T00:00:00.000Z`)) /
           DAY_MILLISECONDS +

package/corpus/templates/analytics/app/pages/adhoc/sql-dashboard/panel-cost-notice.ts

@@ -0,0 +1,172 @@
+import { callAction } from "@agent-native/core/client/hooks";
+import { useFormatters, useT } from "@agent-native/core/client/i18n";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { toast } from "sonner";
+
+import { serializePanelSql } from "./panel-sql";
+import type { SqlPanel } from "./types";
+
+const MIB = 1024 ** 2;
+const GIB = 1024 ** 3;
+const TIB = 1024 ** 4;
+const NOTICE_MS = 8000;
+
+type Formatters = ReturnType<typeof useFormatters>;
+
+export function formatScanSize(bytes: number, formatters: Formatters): string {
+  const [value, unit] =
+    bytes >= TIB
+      ? [bytes / TIB, "TiB"]
+      : bytes >= GIB
+        ? [bytes / GIB, "GiB"]
+        : [bytes / MIB, "MiB"];
+  return `${formatters.formatNumber(value, { maximumFractionDigits: 1 })} ${unit}`;
+}
+
+export function formatQueryUsd(usd: number, formatters: Formatters): string {
+  const money = (value: number) =>
+    formatters.formatNumber(value, {
+      style: "currency",
+      currency: "USD",
+      maximumFractionDigits: 2,
+    });
+  return usd > 0 && usd < 0.01 ? `<${money(0.01)}` : money(usd);
+}
+
+type CostPanel = Pick<SqlPanel, "chartType" | "source" | "sql">;
+
+/** Section and extension panels draw config, so they run no query to price. */
+function runsQuery(panel: CostPanel): boolean {
+  return panel.chartType !== "section" && panel.chartType !== "extension";
+}
+
+/**
+ * What saving a panel means for its cost notice: "notify" to price a new or
+ * changed query, including a section turned into a chart, and "clear" when the
+ * panel stopped running a query. Any other chart-type or config edit reads the
+ * same bytes and changes nothing.
+ */
+export function panelCostChange(
+  before: CostPanel | null,
+  next: CostPanel,
+): "notify" | "clear" | null {
+  if (!runsQuery(next)) return before && runsQuery(before) ? "clear" : null;
+  const changed =
+    !before ||
+    !runsQuery(before) ||
+    before.source !== next.source ||
+    serializePanelSql(before.sql) !== serializePanelSql(next.sql);
+  return changed ? "notify" : null;
+}
+
+async function estimatePanel(dashboardId: string, panelId: string) {
+  try {
+    return await callAction("estimate-query-cost", { dashboardId, panelId });
+  } catch {
+    // coercion-ok: the notice is informational; a failed estimate leaves the save as it was.
+    return null;
+  }
+}
+
+/**
+ * After a save that changed a panel's query, shows what one refresh of that
+ * panel scans and costs in BigQuery, from the same free dry run as
+ * estimate-query-cost. Panels outside BigQuery, and estimates that fail, show
+ * nothing and close the panel's earlier notice. An estimate a newer save of the
+ * panel has replaced shows nothing either. Over
+ * the per-run or per-month threshold the notice stays up until dismissed or
+ * until you leave the dashboard. `clear` closes a panel's notice, and drops its
+ * pending estimate, when the panel stops running a query.
+ */
+export function usePanelCostNotice(dashboardId: string | undefined) {
+  const t = useT();
+  const formatters = useFormatters();
+  // An estimate that lands after leaving the dashboard must not show there,
+  // and its warnings close when you leave.
+  const openDashboardRef = useRef(dashboardId);
+  const warningsRef = useRef(new Set<string>());
+  useEffect(() => {
+    openDashboardRef.current = dashboardId;
+    const warnings = warningsRef.current;
+    return () => {
+      for (const id of warnings) toast.dismiss(id);
+      warnings.clear();
+    };
+  }, [dashboardId]);
+  // Nor may one that lands after a newer save of the same panel.
+  const latestRequestRef = useRef(new Map<string, number>());
+  const requestCountRef = useRef(0);
+  const closeNotice = useCallback((id: string) => {
+    toast.dismiss(id);
+    warningsRef.current.delete(id);
+  }, []);
+
+  const notify = useCallback(
+    async (panelId: string, title: string) => {
+      if (!dashboardId) return;
+      const key = `${dashboardId}:${panelId}`;
+      const request = ++requestCountRef.current;
+      latestRequestRef.current.set(key, request);
+      const result = await estimatePanel(dashboardId, panelId);
+      if (
+        openDashboardRef.current !== dashboardId ||
+        latestRequestRef.current.get(key) !== request
+      ) {
+        return;
+      }
+      const id = `panel-cost:${key}`;
+      const estimate =
+        result && "panels" in result ? result.panels[0] : undefined;
+      if (estimate?.status !== "estimated") {
+        // An earlier notice priced the query this save replaced.
+        closeNotice(id);
+        return;
+      }
+      const over =
+        estimate.overPerRunThreshold || estimate.overPerMonthThreshold;
+      const values = {
+        size: formatScanSize(estimate.estimatedBytes, formatters),
+        perRun: formatQueryUsd(estimate.usdPerRun, formatters),
+        perMonth:
+          estimate.usdPerMonth === null
+            ? ""
+            : formatQueryUsd(estimate.usdPerMonth, formatters),
+      };
+      const cost = t(
+        estimate.usdPerMonth === null
+          ? "sqlDashboard.panelCostUnscheduled"
+          : "sqlDashboard.panelCostScheduled",
+        values,
+      );
+      const options = {
+        id,
+        // The hint goes on its own line under the cost.
+        description: over
+          ? `${cost}\n${t("sqlDashboard.panelCostOverHint")}`
+          : cost,
+        classNames: { description: "whitespace-pre-line" },
+        duration: over ? Number.POSITIVE_INFINITY : NOTICE_MS,
+        closeButton: over,
+      };
+      if (over) {
+        warningsRef.current.add(options.id);
+        toast.warning(t("sqlDashboard.panelCostOverTitle", { title }), options);
+      } else {
+        toast.message(t("sqlDashboard.panelCostTitle", { title }), options);
+      }
+    },
+    [closeNotice, dashboardId, formatters, t],
+  );
+
+  const clear = useCallback(
+    (panelId: string) => {
+      if (!dashboardId) return;
+      const key = `${dashboardId}:${panelId}`;
+      latestRequestRef.current.set(key, ++requestCountRef.current);
+      closeNotice(`panel-cost:${key}`);
+    },
+    [closeNotice, dashboardId],
+  );
+
+  return useMemo(() => ({ notify, clear }), [notify, clear]);
+}