@prenta/core 5.3.0 → 5.4.0

package/dist/api/routes/seo.js

@@ -637,10 +637,47 @@ export function registerSeoRoutes(router) {
         };
     }
     // Demo/seed search-performance rows live in a hidden collection so they can
-    // be inserted by the dev seed script and never ship to npm. In production
-    // with a connected Search Console these would come from the GSC API.
+    // be inserted by the dev seed script and never ship to npm. With a connected
+    // Search Console the synced `searchPageInsight` table takes precedence.
     const SEO_PERF_COLLECTION = '__seo_perf__';
-    async function loadSearchPerformance(limit = 10) {
+    /** Synced GSC data (trailing 28 days). Returns null when there is none yet. */
+    async function loadRealSearchPerformance(limit) {
+        if (!hasModel(db(), 'searchPageInsight'))
+            return null;
+        try {
+            const rows = await db().searchPageInsight.findMany({
+                where: { impressions28d: { gt: 0 } },
+                orderBy: { impressions28d: 'desc' },
+                take: limit,
+            });
+            if (rows.length === 0)
+                return null;
+            const ids = rows.map((r) => r.entityId).filter(Boolean);
+            const titles = new Map();
+            if (ids.length > 0) {
+                const docs = await db().document.findMany({
+                    where: { id: { in: ids } },
+                    select: { id: true, title: true },
+                });
+                for (const d of docs) {
+                    if (d.title)
+                        titles.set(d.id, d.title);
+                }
+            }
+            return rows.map((r) => ({
+                url: r.path,
+                title: (r.entityId && titles.get(r.entityId)) || r.path,
+                impressions: r.impressions28d,
+                clicks: r.clicks28d,
+                ctr: r.impressions28d > 0 ? r.clicks28d / r.impressions28d : 0,
+                averagePosition: r.avgPosition28d ?? 0,
+            }));
+        }
+        catch {
+            return null;
+        }
+    }
+    async function loadDemoSearchPerformance(limit) {
         try {
             const docs = await db().document.findMany({
                 where: { collection: SEO_PERF_COLLECTION, deletedAt: null },
@@ -666,6 +703,65 @@ export function registerSeoRoutes(router) {
             return [];
         }
     }
+    /** Real synced data when connected; `__seo_perf__` demo rows otherwise. */
+    async function loadSearchPerformance(limit = 10, connected = false) {
+        if (connected) {
+            const real = await loadRealSearchPerformance(limit);
+            if (real)
+                return real;
+        }
+        return loadDemoSearchPerformance(limit);
+    }
+    /**
+     * Site-level 28d totals + prior-window deltas from the insight table for the
+     * overview metric cards. Position is impressions-weighted. Null when no
+     * synced data exists (metrics then fall back to the perf-row estimate).
+     */
+    async function loadSearchInsightStats() {
+        if (!hasModel(db(), 'searchPageInsight'))
+            return null;
+        try {
+            const rows = (await db().searchPageInsight.findMany({
+                where: { OR: [{ impressions28d: { gt: 0 } }, { impressionsPrev28d: { gt: 0 } }] },
+                select: {
+                    impressions28d: true,
+                    impressionsPrev28d: true,
+                    avgPosition28d: true,
+                    avgPositionPrev28d: true,
+                },
+                take: 2000,
+            }));
+            if (rows.length === 0)
+                return null;
+            let impressions28d = 0;
+            let impressionsPrev28d = 0;
+            let posWeight = 0;
+            let posWeightBase = 0;
+            let prevPosWeight = 0;
+            let prevPosWeightBase = 0;
+            for (const r of rows) {
+                impressions28d += r.impressions28d;
+                impressionsPrev28d += r.impressionsPrev28d;
+                if (r.avgPosition28d !== null && r.impressions28d > 0) {
+                    posWeight += r.avgPosition28d * r.impressions28d;
+                    posWeightBase += r.impressions28d;
+                }
+                if (r.avgPositionPrev28d !== null && r.impressionsPrev28d > 0) {
+                    prevPosWeight += r.avgPositionPrev28d * r.impressionsPrev28d;
+                    prevPosWeightBase += r.impressionsPrev28d;
+                }
+            }
+            return {
+                impressions28d,
+                impressionsPrev28d,
+                avgPosition: posWeightBase > 0 ? posWeight / posWeightBase : null,
+                avgPositionPrev: prevPosWeightBase > 0 ? prevPosWeight / prevPosWeightBase : null,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
     router.post('/seo/audit', async (request) => {
         try {
             const auth = await requireAuth(request);
@@ -1794,7 +1890,10 @@ export function registerSeoRoutes(router) {
                 ? meta.indexableCount
                 : total;
             const auditTruncated = meta.truncated === true;
-            const perf = await loadSearchPerformance(10);
+            const perf = await loadSearchPerformance(10, moduleSettings.searchConsoleConnected);
+            const searchStats = moduleSettings.searchConsoleConnected
+                ? await loadSearchInsightStats()
+                : null;
             const summary = {
                 total: openIssues.length,
                 critical: openIssues.filter((i) => i.severity === 'critical').length,
@@ -1804,10 +1903,30 @@ export function registerSeoRoutes(router) {
             const scoreAfter = lastRun?.siteScoreAfter ?? null;
             const scoreBefore = lastRun?.siteScoreBefore ?? null;
             const breakdown = lastRun?.metadata?.breakdown ?? [];
-            const avgPosition = perf.length > 0
-                ? perf.reduce((s, r) => s + r.averagePosition, 0) / perf.length
-                : null;
-            const weeklyImpressions = perf.reduce((s, r) => s + r.impressions, 0);
+            // Real site-level stats (weighted by impressions, with prior-window
+            // trends) when synced data exists; the perf-row estimate otherwise.
+            const avgPosition = searchStats?.avgPosition ??
+                (perf.length > 0
+                    ? perf.reduce((s, r) => s + r.averagePosition, 0) / perf.length
+                    : null);
+            const impressions28d = searchStats?.impressions28d ?? perf.reduce((s, r) => s + r.impressions, 0);
+            // Position: lower is better, so an "up" trend means the number dropped.
+            let positionTrend = 'flat';
+            if (searchStats?.avgPosition != null && searchStats.avgPositionPrev != null) {
+                const delta = searchStats.avgPosition - searchStats.avgPositionPrev;
+                if (delta <= -0.5)
+                    positionTrend = 'up';
+                else if (delta >= 0.5)
+                    positionTrend = 'down';
+            }
+            let impressionsTrend = 'flat';
+            if (searchStats && searchStats.impressionsPrev28d > 0) {
+                const ratio = searchStats.impressions28d / searchStats.impressionsPrev28d;
+                if (ratio >= 1.05)
+                    impressionsTrend = 'up';
+                else if (ratio <= 0.95)
+                    impressionsTrend = 'down';
+            }
             const metrics = [
                 {
                     label: 'Pages Indexed',
@@ -1824,16 +1943,42 @@ export function registerSeoRoutes(router) {
                 {
                     label: 'Avg. Position',
                     value: avgPosition !== null ? avgPosition.toFixed(1) : '—',
-                    helper: moduleSettings.searchConsoleConnected ? 'last 28 days' : 'Connect Search Console',
-                    trend: 'flat',
+                    helper: moduleSettings.searchConsoleConnected
+                        ? searchStats?.avgPositionPrev != null
+                            ? `was ${searchStats.avgPositionPrev.toFixed(1)} the prior 28 days`
+                            : 'last 28 days'
+                        : 'Connect Search Console',
+                    trend: positionTrend,
                 },
                 {
-                    label: 'Weekly Impressions',
-                    value: weeklyImpressions > 0 ? formatCompactNumber(weeklyImpressions) : '—',
-                    helper: moduleSettings.searchConsoleConnected ? 'last 28 days' : 'Connect Search Console',
-                    trend: 'flat',
+                    label: 'Impressions',
+                    value: impressions28d > 0 ? formatCompactNumber(impressions28d) : '—',
+                    helper: moduleSettings.searchConsoleConnected
+                        ? searchStats && searchStats.impressionsPrev28d > 0
+                            ? `was ${formatCompactNumber(searchStats.impressionsPrev28d)} the prior 28 days`
+                            : 'last 28 days'
+                        : 'Connect Search Console',
+                    trend: impressionsTrend,
                 },
             ];
+            // Weight quick wins by real traffic when synced search data exists.
+            const impressionsByEntityId = {};
+            if (moduleSettings.searchConsoleConnected && hasModel(db(), 'searchPageInsight')) {
+                try {
+                    const impressionRows = (await db().searchPageInsight.findMany({
+                        where: { entityId: { not: null }, impressions28d: { gt: 0 } },
+                        select: { entityId: true, impressions28d: true },
+                        take: 2000,
+                    }));
+                    for (const r of impressionRows) {
+                        if (r.entityId)
+                            impressionsByEntityId[r.entityId] = r.impressions28d;
+                    }
+                }
+                catch {
+                    /* weighting is optional */
+                }
+            }
             const quickWins = buildQuickWins(openIssues.map((i) => ({
                 issueKey: i.issueKey,
                 entityType: i.entityType,
@@ -1850,7 +1995,7 @@ export function registerSeoRoutes(router) {
                 fixable: i.fixable ?? false,
                 fixActionType: i.fixActionType ?? null,
                 relatedEntityIds: Array.isArray(i.relatedEntityIds) ? i.relatedEntityIds : [],
-            }))).map((w) => ({
+            })), { impressionsByEntityId }).map((w) => ({
                 id: w.id,
                 title: w.title,
                 explanation: w.explanation,
@@ -1888,13 +2033,68 @@ export function registerSeoRoutes(router) {
                 return auth.error;
             const url = new URL(request.url);
             const limit = Math.min(50, Math.max(1, Number(url.searchParams.get('limit') ?? 10)));
-            const rows = await loadSearchPerformance(limit);
+            const { getSeoOverrides, resolveSeoModuleSettings } = await import('../../seo/config-store.js');
+            const settings = resolveSeoModuleSettings(await getSeoOverrides(db()));
+            const rows = await loadSearchPerformance(limit, settings.searchConsoleConnected);
             return json({ data: { rows } });
         }
         catch (err) {
             return internalError(err, 'seo/search-performance');
         }
     });
+    // Per-document search insight (synced GSC + CrUX) for the editor pane's
+    // read-only stats block. `insight: null` when not synced or no data.
+    router.get('/seo/search-insights/:entityId', async (request, params) => {
+        try {
+            const auth = await requireAuth(request);
+            if (auth.error)
+                return auth.error;
+            const entityId = params.entityId;
+            if (!entityId)
+                return errorResponse('entityId is required', 400);
+            const { getSeoOverrides, resolveSeoModuleSettings } = await import('../../seo/config-store.js');
+            const settings = resolveSeoModuleSettings(await getSeoOverrides(db()));
+            const connected = settings.searchConsoleConnected;
+            if (!connected || !hasModel(db(), 'searchPageInsight')) {
+                return json({ data: { connected, insight: null } });
+            }
+            const row = await db().searchPageInsight.findFirst({
+                where: { entityId },
+                select: {
+                    path: true,
+                    clicks28d: true,
+                    impressions28d: true,
+                    avgPosition28d: true,
+                    clicksPrev28d: true,
+                    impressionsPrev28d: true,
+                    avgPositionPrev28d: true,
+                    topQueries: true,
+                    lcpMs: true,
+                    inpMs: true,
+                    cls: true,
+                    cwvStatus: true,
+                    lastSyncedAt: true,
+                },
+            });
+            return json({
+                data: {
+                    connected,
+                    insight: row
+                        ? {
+                            ...row,
+                            topQueries: Array.isArray(row.topQueries) ? row.topQueries : [],
+                            lastSyncedAt: row.lastSyncedAt instanceof Date
+                                ? row.lastSyncedAt.toISOString()
+                                : row.lastSyncedAt,
+                        }
+                        : null,
+                },
+            });
+        }
+        catch (err) {
+            return internalError(err, 'seo/search-insights');
+        }
+    });
     router.get('/seo/content', async (request) => {
         try {
             const auth = await requireAuth(request);