@actuate-media/cms-core 0.89.0 → 0.90.0

package/dist/api/routes/seo.js

@@ -9,7 +9,7 @@ import { syncSchemaTypeFields } from '../../seo/schema-sync.js';
 import { guardedDb } from '../guarded-db.js';
 import { recordAiCrawlerFromRequest, recordAiCrawlerHit } from '../../seo/ai-crawler-log.js';
 import { detectAiBot } from '../../seo/ai-bots.js';
-import { json, errorResponse, internalError, asRecord, normalizeSeoPage, hasModel, formatCompactNumber, modelNotAvailable, requireAuth, buildActionContext, WRITE_ROLES, ADMIN_ROLES, requireRole, linkHealthLimiter, seoAuditLimiter, aiGenerateLimiter, checkRateLimitAsync, clientIp, enforceDocumentReadAccess, } from '../route-helpers.js';
+import { json, errorResponse, internalError, asRecord, normalizeSeoPage, hasModel, formatCompactNumber, modelNotAvailable, requireAuth, buildActionContext, WRITE_ROLES, ADMIN_ROLES, requireRole, linkHealthLimiter, seoAuditLimiter, aiGenerateLimiter, checkRateLimitAsync, clientIp, enforceDocumentReadAccess, importAIPlugin, } from '../route-helpers.js';
 // Explicit risk order. A plain `severity: 'asc'` DB sort orders the values
 // alphabetically (critical, info, warning) which wrongly ranks `info` above
 // `warning`. Unknown severities sort last.
@@ -91,37 +91,49 @@ export function registerSeoRoutes(router) {
             }
             const MAX_LINKS_PER_PAGE = 50;
             const MAX_TOTAL_LINKS = 500;
+            const DOC_BATCH_SIZE = 100;
             const PER_LINK_TIMEOUT_MS = 4000;
             const CONCURRENCY = 8;
-            const docs = await db().document.findMany({
-                where: { deletedAt: null, status: 'PUBLISHED' },
-                select: { id: true, title: true, data: true, collection: true },
-            });
             const urlRegex = /https?:\/\/[^\s"'<>]+/g;
             const siteUrl = process.env.NEXT_PUBLIC_SITE_URL ?? '';
             const queue = [];
             const seenGlobal = new Set();
-            outer: for (const doc of docs) {
-                const pageTitle = doc.title ?? doc.data?.title ?? doc.id;
-                const content = JSON.stringify(doc.data ?? {});
-                const urls = content.match(urlRegex) ?? [];
-                const seenInPage = new Set();
-                let countInPage = 0;
-                for (const url of urls) {
-                    const clean = url.replace(/[",;)}\]]+$/, '');
-                    if (seenInPage.has(clean))
-                        continue;
-                    seenInPage.add(clean);
-                    if (seenGlobal.has(clean))
-                        continue;
-                    seenGlobal.add(clean);
-                    if (countInPage >= MAX_LINKS_PER_PAGE)
-                        break;
-                    if (queue.length >= MAX_TOTAL_LINKS)
-                        break outer;
-                    const isInternal = !!siteUrl && clean.startsWith(siteUrl);
-                    queue.push({ docId: doc.id, pageTitle, clean, isInternal });
-                    countInPage++;
+            let docsScanned = 0;
+            let skip = 0;
+            scanLoop: while (queue.length < MAX_TOTAL_LINKS) {
+                const batch = await db().document.findMany({
+                    where: { deletedAt: null, status: 'PUBLISHED' },
+                    select: { id: true, title: true, data: true, collection: true },
+                    orderBy: { updatedAt: 'desc' },
+                    skip,
+                    take: DOC_BATCH_SIZE,
+                });
+                if (batch.length === 0)
+                    break;
+                docsScanned += batch.length;
+                skip += batch.length;
+                for (const doc of batch) {
+                    const pageTitle = doc.title ?? doc.data?.title ?? doc.id;
+                    const content = JSON.stringify(doc.data ?? {});
+                    const urls = content.match(urlRegex) ?? [];
+                    const seenInPage = new Set();
+                    let countInPage = 0;
+                    for (const url of urls) {
+                        const clean = url.replace(/[",;)}\]]+$/, '');
+                        if (seenInPage.has(clean))
+                            continue;
+                        seenInPage.add(clean);
+                        if (seenGlobal.has(clean))
+                            continue;
+                        seenGlobal.add(clean);
+                        if (countInPage >= MAX_LINKS_PER_PAGE)
+                            break;
+                        if (queue.length >= MAX_TOTAL_LINKS)
+                            break scanLoop;
+                        const isInternal = !!siteUrl && clean.startsWith(siteUrl);
+                        queue.push({ docId: doc.id, pageTitle, clean, isInternal });
+                        countInPage++;
+                    }
                 }
             }
             const linkResults = [];
@@ -165,6 +177,7 @@ export function registerSeoRoutes(router) {
             return json({
                 data: {
                     truncated: queue.length >= MAX_TOTAL_LINKS,
+                    docsScanned,
                     checked: queue.length,
                     issues: linkResults,
                 },
@@ -174,6 +187,197 @@ export function registerSeoRoutes(router) {
             return internalError(err);
         }
     });
+    router.get('/seo/links/snapshot', async (request) => {
+        try {
+            const auth = await requireAuth(request);
+            if (auth.error)
+                return auth.error;
+            const roleErr = requireRole(auth.session.role, WRITE_ROLES);
+            if (roleErr)
+                return roleErr;
+            const { gatherAuditEntities, frontEndContentCollectionTypes } = await import('../../seo/audit-runner.js');
+            const { buildLinkGraphSnapshot } = await import('../../seo/link-graph.js');
+            const { getSeoOverrides, resolveSeoModuleSettings } = await import('../../seo/config-store.js');
+            const cfg = getActuateConfig();
+            const collectionTypes = frontEndContentCollectionTypes(cfg);
+            const siteUrl = cfg?.seo?.siteUrl?.replace(/\/+$/, '') ?? '';
+            const entities = await gatherAuditEntities(db(), { collectionTypes });
+            const docRows = await db()
+                .document.findMany({
+                where: {
+                    deletedAt: null,
+                    status: 'PUBLISHED',
+                    collection: { in: Object.keys(collectionTypes) },
+                },
+                select: { id: true, collection: true },
+            })
+                .catch(() => []);
+            const collections = Object.fromEntries(docRows.map((d) => [d.id, d.collection]));
+            let brokenLinkCount = 0;
+            if (hasModel(db(), 'seoIssue')) {
+                brokenLinkCount = await db()
+                    .seoIssue.count({
+                    where: {
+                        status: { in: ['open', 'recurring'] },
+                        type: 'broken-internal-link',
+                    },
+                })
+                    .catch(() => 0);
+            }
+            const overrides = await getSeoOverrides(db()).catch(() => null);
+            const moduleSettings = resolveSeoModuleSettings(overrides);
+            const snapshot = buildLinkGraphSnapshot({
+                entities,
+                siteUrl,
+                collections,
+                brokenLinkCount,
+                aiIndexLastRunAt: moduleSettings.linkAiIndexLastRunAt,
+            });
+            return json({ data: snapshot });
+        }
+        catch (err) {
+            return internalError(err, 'seo/links/snapshot');
+        }
+    });
+    router.post('/seo/links/ai-index', async (request) => {
+        try {
+            const auth = await requireAuth(request);
+            if (auth.error)
+                return auth.error;
+            const roleErr = requireRole(auth.session.role, WRITE_ROLES);
+            if (roleErr)
+                return roleErr;
+            if (!(await checkRateLimitAsync(aiGenerateLimiter, `link-ai-index:${auth.session.userId}`))) {
+                return errorResponse('AI link index rate limit reached. Try again later.', 429);
+            }
+            const { gatherAuditEntities, frontEndContentCollectionTypes } = await import('../../seo/audit-runner.js');
+            const { patchSeoModuleSettings } = await import('../../seo/config-store.js');
+            const cfg = getActuateConfig();
+            const collectionTypes = frontEndContentCollectionTypes(cfg);
+            const entities = await gatherAuditEntities(db(), { collectionTypes });
+            let aiAvailable = false;
+            try {
+                await importAIPlugin();
+                aiAvailable = true;
+            }
+            catch {
+                aiAvailable = false;
+            }
+            const now = new Date().toISOString();
+            await patchSeoModuleSettings(db(), { linkAiIndexLastRunAt: now }, auth.session.userId);
+            await logEvent({
+                event: 'seo_link_ai_index',
+                userId: auth.session.userId,
+                details: { entitiesIndexed: entities.length, aiAvailable },
+            });
+            return json({
+                data: {
+                    indexedAt: now,
+                    entitiesIndexed: entities.length,
+                    aiAvailable,
+                    message: aiAvailable
+                        ? 'Content indexed for AI link suggestions. Run suggestions on orphaned or under-linked pages.'
+                        : 'Link graph refreshed. Install @actuate-media/plugin-ai for semantic AI suggestions.',
+                },
+            });
+        }
+        catch (err) {
+            return internalError(err, 'seo/links/ai-index');
+        }
+    });
+    router.post('/seo/links/suggest', async (request) => {
+        try {
+            const auth = await requireAuth(request);
+            if (auth.error)
+                return auth.error;
+            const roleErr = requireRole(auth.session.role, WRITE_ROLES);
+            if (roleErr)
+                return roleErr;
+            if (!(await checkRateLimitAsync(aiGenerateLimiter, `link-suggest:${auth.session.userId}`))) {
+                return errorResponse('Link suggestion rate limit reached. Try again later.', 429);
+            }
+            const body = (await request.json());
+            if (!body.targetEntityId || !body.targetEntityType) {
+                return errorResponse('targetEntityId and targetEntityType are required', 400);
+            }
+            const limit = Math.max(1, Math.min(20, typeof body.limit === 'number' ? body.limit : 8));
+            const { gatherAuditEntities, frontEndContentCollectionTypes } = await import('../../seo/audit-runner.js');
+            const cfg = getActuateConfig();
+            const collectionTypes = frontEndContentCollectionTypes(cfg);
+            const entities = await gatherAuditEntities(db(), { collectionTypes });
+            const target = entities.find((e) => e.entityId === body.targetEntityId);
+            if (!target)
+                return errorResponse('Target document not found in link graph', 404);
+            const sources = entities.filter((e) => e.entityId !== target.entityId);
+            const query = [target.title, target.focusKeyword, target.metaDescription]
+                .filter(Boolean)
+                .join(' — ');
+            const docRows = await db()
+                .document.findMany({
+                where: { id: { in: sources.map((s) => s.entityId) } },
+                select: { id: true, collection: true },
+            })
+                .catch(() => []);
+            const collections = Object.fromEntries(docRows.map((d) => [d.id, d.collection]));
+            let suggestions = [];
+            try {
+                const aiModule = await importAIPlugin();
+                if (typeof aiModule?.semanticSearch === 'function') {
+                    const corpus = sources.map((s) => ({
+                        id: s.entityId,
+                        collectionSlug: collections[s.entityId] ?? 'pages',
+                        title: s.title,
+                        content: (s.content ?? '').slice(0, 8000),
+                    }));
+                    const results = await aiModule.semanticSearch(query, { limit, threshold: 0.35, corpus });
+                    suggestions = results.map((r) => ({
+                        sourceEntityId: r.id,
+                        sourceTitle: r.title,
+                        sourceUrl: sources.find((s) => s.entityId === r.id)?.url ?? '',
+                        anchorText: target.title,
+                        confidence: Math.round(r.score * 100) / 100,
+                        excerpt: r.excerpt,
+                    }));
+                }
+                else if (typeof aiModule?.suggestInternalLinks === 'function') {
+                    for (const source of sources.slice(0, 40)) {
+                        const found = await aiModule.suggestInternalLinks(source.content ?? '', [
+                            {
+                                id: target.entityId,
+                                title: target.title,
+                                url: target.url,
+                                keywords: target.focusKeyword ? [target.focusKeyword] : [],
+                            },
+                        ]);
+                        for (const f of found.slice(0, 2)) {
+                            suggestions.push({
+                                sourceEntityId: source.entityId,
+                                sourceTitle: source.title,
+                                sourceUrl: source.url,
+                                anchorText: f.anchorText,
+                                confidence: f.confidence,
+                                excerpt: (source.content ?? '').slice(f.position.start, f.position.end + 40),
+                            });
+                        }
+                    }
+                    suggestions.sort((a, b) => b.confidence - a.confidence);
+                    suggestions = suggestions.slice(0, limit);
+                }
+            }
+            catch {
+                suggestions = [];
+            }
+            return json({
+                data: {
+                    target: { id: target.entityId, title: target.title, url: target.url },
+                    suggestions,
+                },
+            });
+        }
+        catch (err) {
+            return internalError(err, 'seo/links/suggest');
+        }
+    });
     router.post('/seo/scan', async (request) => {
         try {
             const auth = await requireAuth(request);
@@ -233,8 +437,11 @@ export function registerSeoRoutes(router) {
     }
     async function buildSeoContentRecords() {
         const { gatherAuditEntities, frontEndContentCollectionTypes } = await import('../../seo/audit-runner.js');
+        const { applySeoOverrides, getSeoOverrides } = await import('../../seo/config-store.js');
         const { calculatePageSeoScore } = await import('../../seo/score.js');
         const collectionTypes = frontEndContentCollectionTypes(getActuateConfig());
+        const overrides = await getSeoOverrides(db()).catch(() => null);
+        const siteSeo = applySeoOverrides(getActuateConfig(), overrides)?.seo;
         const entities = await gatherAuditEntities(db(), { collectionTypes });
         return entities.map((e) => {
             const score = calculatePageSeoScore(e);
@@ -245,7 +452,12 @@ export function registerSeoRoutes(router) {
                 title: e.title,
                 url: e.url,
                 canonicalUrl: e.canonicalUrl ?? null,
+                /** Rendered public title (after site title template). */
                 metaTitle: e.metaTitle ?? null,
+                /** Stored page-specific portion (`%page%` token). */
+                metaTitlePage: e.metaTitlePage ?? null,
+                siteName: siteSeo?.siteName ?? null,
+                titleTemplate: siteSeo?.titleTemplate ?? null,
                 metaDescription: e.metaDescription ?? null,
                 focusKeyword: e.focusKeyword ?? null,
                 keyTakeaway: e.keyTakeaway ?? null,
@@ -983,18 +1195,29 @@ export function registerSeoRoutes(router) {
                 entity: loaded.entity,
                 siteSeo: loaded.siteSeo,
                 updatedAt: loaded.updatedAt,
+                metadata: asRecord(issue.metadata),
             };
             let aiDeps;
-            const adminErr = requireRole(auth.session.role, ADMIN_ROLES);
-            if (!adminErr &&
-                hasPlanFeature('seo.inlineApply') &&
-                (await checkRateLimitAsync(aiGenerateLimiter, `ai-seo-fix-suggest:${auth.session.userId}`))) {
+            const { REDIRECT_FIX_TYPES } = await import('../../seo/issue-fix-redirect.js');
+            if (REDIRECT_FIX_TYPES.has(issue.type)) {
                 aiDeps = {
                     db: db(),
                     userId: auth.session.userId,
                     collection: loaded.collection,
                 };
             }
+            else {
+                const adminErr = requireRole(auth.session.role, ADMIN_ROLES);
+                if (!adminErr &&
+                    hasPlanFeature('seo.inlineApply') &&
+                    (await checkRateLimitAsync(aiGenerateLimiter, `ai-seo-fix-suggest:${auth.session.userId}`))) {
+                    aiDeps = {
+                        db: db(),
+                        userId: auth.session.userId,
+                        collection: loaded.collection,
+                    };
+                }
+            }
             const { suggestIssueFix } = await import('../../seo/issue-fix.js');
             const { pendingFixToMetadata } = await import('../../seo/issue-fix-ai.js');
             const result = await suggestIssueFix(issueInput, fixCtx, aiDeps);
@@ -1043,7 +1266,79 @@ export function registerSeoRoutes(router) {
                 entity: loaded.entity,
                 siteSeo: loaded.siteSeo,
                 updatedAt: loaded.updatedAt,
+                metadata: asRecord(issue.metadata),
             };
+            const { REDIRECT_FIX_TYPES, applyBrokenLinkRedirectFix, applyBrokenLinkContentFix } = await import('../../seo/issue-fix-redirect.js');
+            if (REDIRECT_FIX_TYPES.has(issue.type)) {
+                const { pendingFixFromMetadata } = await import('../../seo/issue-fix-ai.js');
+                const { buildFixFingerprint } = await import('../../seo/issue-fix.js');
+                const cached = pendingFixFromMetadata(issue.metadata);
+                const liveFingerprint = buildFixFingerprint(loaded.entity.entityId, issue.type, loaded.updatedAt);
+                if (!cached?.autoFixable) {
+                    return errorResponse('This issue does not support an automatic fix.', 422);
+                }
+                if (body?.fingerprint && body.fingerprint !== cached.fingerprint) {
+                    return errorResponse('This fix is stale — the page changed since the suggestion was loaded. Expand the row again.', 409);
+                }
+                if (cached.fingerprint !== liveFingerprint) {
+                    return errorResponse('This fix is stale — the page changed since the suggestion was loaded. Expand the row again.', 409);
+                }
+                const fixStrategy = cached.patch.fixStrategy === 'fix-link' ? 'fix-link' : 'redirect';
+                try {
+                    if (fixStrategy === 'fix-link') {
+                        const ctx = buildActionContext(auth.session, db());
+                        await applyBrokenLinkContentFix(loaded.collection, loaded.entity.entityId, cached.patch, ctx);
+                    }
+                    else {
+                        await applyBrokenLinkRedirectFix(db(), cached.patch, auth.session.userId);
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : 'Fix application failed';
+                    return errorResponse(msg, 400);
+                }
+                const existingMeta = asRecord(issue.metadata);
+                const resolved = await db().seoIssue.update({
+                    where: { id: issue.id },
+                    data: {
+                        status: 'resolved',
+                        resolvedAt: new Date(),
+                        resolvedById: auth.session.userId,
+                        metadata: { ...existingMeta, pendingFix: null },
+                    },
+                });
+                try {
+                    await logEvent({
+                        event: 'document_updated',
+                        userId: auth.session.userId,
+                        details: {
+                            action: fixStrategy === 'fix-link'
+                                ? 'seo_issue_link_fix_applied'
+                                : 'seo_issue_redirect_applied',
+                            issueId: issue.id,
+                            issueType: issue.type,
+                            ...(fixStrategy === 'fix-link'
+                                ? {
+                                    fixLinkFrom: cached.patch.fixLinkFrom,
+                                    fixLinkTo: cached.patch.fixLinkTo,
+                                }
+                                : {
+                                    redirectFrom: cached.patch.redirectFrom,
+                                    redirectTo: cached.patch.redirectTo,
+                                }),
+                        },
+                    });
+                }
+                catch {
+                    /* noop */
+                }
+                return json({
+                    data: {
+                        issue: seoIssueToApi(resolved),
+                        applied: cached.changes,
+                    },
+                });
+            }
             const { suggestDeterministicFix, buildFixFingerprint } = await import('../../seo/issue-fix.js');
             const { pendingFixFromMetadata } = await import('../../seo/issue-fix-ai.js');
             const deterministic = suggestDeterministicFix(issueInput, fixCtx);