@canvas-digital/blog-sdk 2.0.0

package/dist/lib/queries.js

@@ -0,0 +1,340 @@
+import { unstable_cache } from 'next/cache';
+import { getPayloadClient } from './tenant';
+import { tags } from './revalidate';
+/**
+ * Read paths for the public renderer.
+ *
+ * Each query is wrapped in a cache entry tagged with the same tags the publish
+ * hook invalidates, so a publish evicts exactly the pages it affects and leaves
+ * everything else warm at the edge.
+ *
+ * These run through the Local API — an in-process function call, not an HTTP
+ * request — so there is no network hop between the renderer and the database.
+ */
+export const POSTS_PER_PAGE = 12;
+const publishedPublicWhere = (tenantId, categoryId, q) => {
+    const and = [
+        { _status: { equals: 'published' } },
+        {
+            or: [
+                { visibility: { equals: 'public' } },
+                { visibility: { exists: false } },
+            ],
+        },
+    ];
+    if (tenantId != null)
+        and.push({ tenant: { equals: tenantId } });
+    if (categoryId != null)
+        and.push({ category: { equals: categoryId } });
+    const query = q?.trim();
+    if (query) {
+        and.push({
+            or: [{ title: { like: query } }, { excerpt: { like: query } }],
+        });
+    }
+    return { and };
+};
+export const getPublicBrands = () => unstable_cache(async () => {
+    const payload = await getPayloadClient();
+    const res = await payload.find({
+        collection: 'tenants',
+        sort: 'name',
+        limit: 100,
+        depth: 0,
+        pagination: false,
+        overrideAccess: true,
+    });
+    return res.docs.map((t) => ({
+        id: String(t.id),
+        name: t.name,
+        slug: t.slug,
+    }));
+}, ['tenants', 'public-brands'], { tags: ['tenant:all'], revalidate: 60 });
+/** Public listing used by /api/blogs — supports brand scope + search. */
+export const findPublicPosts = async (args) => {
+    const payload = await getPayloadClient();
+    return payload.find({
+        collection: 'posts',
+        where: publishedPublicWhere(args.tenantId, args.categoryId, args.q),
+        sort: '-publishedAt',
+        limit: POSTS_PER_PAGE,
+        page: args.page ?? 1,
+        depth: 2,
+        draft: false,
+        overrideAccess: true,
+    });
+};
+export const getPublishedPosts = (tenantId, tenantSlug) => unstable_cache(async (page = 1, categoryId) => {
+    const payload = await getPayloadClient();
+    return payload.find({
+        collection: 'posts',
+        where: publishedPublicWhere(tenantId, categoryId),
+        sort: '-publishedAt',
+        limit: POSTS_PER_PAGE,
+        page,
+        depth: 2,
+        draft: false,
+        // Access rules are for editors; the where clause already limits to public published posts.
+        overrideAccess: true,
+    });
+}, ['posts', String(tenantId)], { tags: [tags.postIndex(tenantSlug), tags.tenant(tenantSlug)], revalidate: 60 });
+/** Shared preview hosts (admin "All brands"): every published public post, same DATABASE_URI. */
+export const getAllPublishedPosts = () => unstable_cache(async (page = 1, categoryId) => {
+    const payload = await getPayloadClient();
+    return payload.find({
+        collection: 'posts',
+        where: publishedPublicWhere(null, categoryId),
+        sort: '-publishedAt',
+        limit: POSTS_PER_PAGE,
+        page,
+        depth: 2,
+        draft: false,
+        overrideAccess: true,
+    });
+}, ['posts', 'all-brands'], { tags: [tags.postIndex('all'), 'tenant:all'], revalidate: 60 });
+export const getPostBySlug = (tenantId, tenantSlug) => unstable_cache(async (slug) => {
+    const payload = await getPayloadClient();
+    const res = await payload.find({
+        collection: 'posts',
+        where: {
+            and: [
+                { tenant: { equals: tenantId } },
+                { slug: { equals: slug } },
+                { _status: { equals: 'published' } },
+                {
+                    or: [
+                        { visibility: { equals: 'public' } },
+                        { visibility: { exists: false } },
+                    ],
+                },
+            ],
+        },
+        limit: 1,
+        depth: 2,
+        pagination: false,
+        draft: false,
+        overrideAccess: true,
+    });
+    return res.docs[0] ?? null;
+}, ['post', String(tenantId)], { tags: [tags.tenant(tenantSlug)] });
+/**
+ * Uncached draft/live lookup for `/api/preview`. Must not use unstable_cache —
+ * editors need the exact document they just saved, including unpublished drafts.
+ */
+export const getPostBySlugPreview = async (tenantId, slug) => {
+    const payload = await getPayloadClient();
+    const res = await payload.find({
+        collection: 'posts',
+        where: {
+            and: [{ tenant: { equals: tenantId } }, { slug: { equals: slug } }],
+        },
+        limit: 1,
+        depth: 2,
+        pagination: false,
+        draft: true,
+        overrideAccess: true,
+    });
+    return res.docs[0] ?? null;
+};
+export const getCategoryBySlug = (tenantId, tenantSlug) => unstable_cache(async (slug) => {
+    const payload = await getPayloadClient();
+    const res = await payload.find({
+        collection: 'categories',
+        where: {
+            and: [{ tenant: { equals: tenantId } }, { slug: { equals: slug } }],
+        },
+        limit: 1,
+        depth: 1,
+        pagination: false,
+        overrideAccess: true,
+    });
+    return res.docs[0] ?? null;
+}, ['category', String(tenantId)], { tags: [tags.tenant(tenantSlug)] });
+export const getCategories = (tenantId, tenantSlug) => unstable_cache(async () => {
+    const payload = await getPayloadClient();
+    const res = await payload.find({
+        collection: 'categories',
+        where: { tenant: { equals: tenantId } },
+        sort: 'name',
+        limit: 100,
+        depth: 0,
+        pagination: false,
+        overrideAccess: true,
+    });
+    return res.docs;
+}, ['categories', String(tenantId)], { tags: [tags.tenant(tenantSlug)] });
+export const getAllCategories = () => unstable_cache(async () => {
+    const payload = await getPayloadClient();
+    const res = await payload.find({
+        collection: 'categories',
+        sort: 'name',
+        limit: 200,
+        depth: 0,
+        pagination: false,
+        overrideAccess: true,
+    });
+    return res.docs;
+}, ['categories', 'all-brands'], { tags: ['tenant:all'], revalidate: 60 });
+/**
+ * Related posts, used for internal linking. Same category first, then most
+ * recent, always excluding the current post.
+ */
+export const getRelatedPosts = (tenantId, tenantSlug) => unstable_cache(async (postId, categoryId, limit = 3) => {
+    const payload = await getPayloadClient();
+    const base = [
+        { tenant: { equals: tenantId } },
+        { _status: { equals: 'published' } },
+        { id: { not_equals: postId } },
+    ];
+    if (categoryId != null) {
+        const sameCategory = await payload.find({
+            collection: 'posts',
+            where: { and: [...base, { category: { equals: categoryId } }] },
+            sort: '-publishedAt',
+            limit,
+            depth: 1,
+            pagination: false,
+            draft: false,
+            overrideAccess: false,
+        });
+        if (sameCategory.docs.length >= limit)
+            return sameCategory.docs;
+        const seen = sameCategory.docs.map((d) => d.id);
+        const fillerWhere = [...base];
+        if (seen.length)
+            fillerWhere.push({ id: { not_in: seen } });
+        const filler = await payload.find({
+            collection: 'posts',
+            where: { and: fillerWhere },
+            sort: '-publishedAt',
+            limit: limit - sameCategory.docs.length,
+            depth: 1,
+            pagination: false,
+            draft: false,
+            overrideAccess: false,
+        });
+        return [...sameCategory.docs, ...filler.docs];
+    }
+    const recent = await payload.find({
+        collection: 'posts',
+        where: { and: base },
+        sort: '-publishedAt',
+        limit,
+        depth: 1,
+        pagination: false,
+        draft: false,
+        overrideAccess: false,
+    });
+    return recent.docs;
+}, ['related', String(tenantId)], { tags: [tags.postIndex(tenantSlug)] });
+/** Brand published posts for the article-side Table of Contents rail. */
+export const getBrandTocPosts = (tenantId, tenantSlug) => unstable_cache(async (limit = 12) => {
+    const payload = await getPayloadClient();
+    const result = await payload.find({
+        collection: 'posts',
+        where: {
+            and: [
+                { tenant: { equals: tenantId } },
+                { _status: { equals: 'published' } },
+                {
+                    or: [
+                        { visibility: { equals: 'public' } },
+                        { visibility: { exists: false } },
+                    ],
+                },
+            ],
+        },
+        sort: '-publishedAt',
+        limit,
+        depth: 0,
+        pagination: false,
+        draft: false,
+        overrideAccess: true,
+        select: {
+            id: true,
+            title: true,
+            slug: true,
+            publishedAt: true,
+            readingMinutes: true,
+        },
+    });
+    return result.docs;
+}, ['brand-toc', String(tenantId)], { tags: [tags.postIndex(tenantSlug)] });
+/** Every published post for the sitemap, id + slug + timestamps only. */
+export const getSitemapEntries = (tenantId, tenantSlug) => unstable_cache(async () => {
+    const payload = await getPayloadClient();
+    const [posts, categories] = await Promise.all([
+        payload.find({
+            collection: 'posts',
+            where: {
+                and: [
+                    { tenant: { equals: tenantId } },
+                    { _status: { equals: 'published' } },
+                    // Pages marked noindex must not appear in the sitemap — telling
+                    // Google to crawl a page you told it not to index is a conflict
+                    // that shows up as a coverage error.
+                    { 'seo.noindex': { not_equals: true } },
+                ],
+            },
+            sort: '-publishedAt',
+            limit: 50000,
+            depth: 0,
+            pagination: false,
+            draft: false,
+            overrideAccess: true,
+        }),
+        payload.find({
+            collection: 'categories',
+            where: {
+                and: [
+                    { tenant: { equals: tenantId } },
+                    { 'seo.noindex': { not_equals: true } },
+                ],
+            },
+            limit: 1000,
+            depth: 0,
+            pagination: false,
+            overrideAccess: true,
+        }),
+    ]);
+    return { posts: posts.docs, categories: categories.docs };
+}, ['sitemap', String(tenantId)], { tags: [tags.sitemap(tenantSlug), tags.tenant(tenantSlug)] });
+export const getAuthorBySlug = (tenantId, tenantSlug) => unstable_cache(async (slug) => {
+    const payload = await getPayloadClient();
+    const res = await payload.find({
+        collection: 'authors',
+        where: {
+            and: [{ tenant: { equals: tenantId } }, { slug: { equals: slug } }],
+        },
+        limit: 1,
+        depth: 1,
+        pagination: false,
+        overrideAccess: true,
+    });
+    return res.docs[0] ?? null;
+}, ['author', String(tenantId)], { tags: [tags.tenant(tenantSlug)] });
+export const getPostsByAuthor = (tenantId, tenantSlug) => unstable_cache(async (authorId, page = 1) => {
+    const payload = await getPayloadClient();
+    return payload.find({
+        collection: 'posts',
+        where: {
+            and: [
+                { tenant: { equals: tenantId } },
+                { _status: { equals: 'published' } },
+                {
+                    or: [
+                        { visibility: { equals: 'public' } },
+                        { visibility: { exists: false } },
+                    ],
+                },
+                { authors: { contains: authorId } },
+            ],
+        },
+        sort: '-publishedAt',
+        limit: POSTS_PER_PAGE,
+        page,
+        depth: 2,
+        draft: false,
+        overrideAccess: true,
+    });
+}, ['author-posts', String(tenantId)], { tags: [tags.postIndex(tenantSlug), tags.tenant(tenantSlug)] });

package/dist/lib/redirect-analytics.d.ts

@@ -0,0 +1,27 @@
+import type { DayPoint, Bucket } from './stats';
+/**
+ * Aggregations for the Custom redirection analytics screen.
+ */
+export type RedirectLogRow = {
+    id: string;
+    at: string;
+    from: string;
+    to: string;
+    type: string;
+    ok: boolean;
+};
+export type RedirectAnalyticsData = {
+    totalRules: number;
+    hitsToday: number;
+    hitsWeek: number;
+    hitsMonth: number;
+    topRedirects: Bucket[];
+    brokenUrls: Bucket[];
+    series: DayPoint[];
+    recentLogs: RedirectLogRow[];
+};
+export declare const loadRedirectAnalytics: (args: {
+    tenantIds: string[];
+    totalRules: number;
+}) => Promise<RedirectAnalyticsData>;
+//# sourceMappingURL=redirect-analytics.d.ts.map

package/dist/lib/redirect-analytics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redirect-analytics.d.ts","sourceRoot":"","sources":["../../app/lib/redirect-analytics.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAE/C;;GAEG;AAEH,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,OAAO,CAAA;CACZ,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,MAAM,EAAE,QAAQ,EAAE,CAAA;IAClB,UAAU,EAAE,cAAc,EAAE,CAAA;CAC7B,CAAA;AAkCD,eAAO,MAAM,qBAAqB,GAAU,MAAM;IAChD,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;CACnB,KAAG,OAAO,CAAC,qBAAqB,CAsIhC,CAAA"}

package/dist/lib/redirect-analytics.js

@@ -0,0 +1,147 @@
+import { getPayloadClient } from './tenant';
+import { daysBack } from './stats';
+const rawDb = async () => {
+    const payload = await getPayloadClient();
+    return payload.db.connection?.db ?? null;
+};
+const utcDay = (d = new Date()) => d.toISOString().slice(0, 10);
+const sumHits = async (db, tenantIds, fromDate, toDate) => {
+    const match = {
+        tenant: { $in: tenantIds },
+        date: toDate ? { $gte: fromDate, $lte: toDate } : { $gte: fromDate },
+    };
+    const rows = await db
+        .collection('redirect-analytics')
+        .aggregate([{ $match: match }, { $group: { _id: null, total: { $sum: '$hits' } } }])
+        .toArray();
+    return Number(rows[0]?.total ?? 0);
+};
+export const loadRedirectAnalytics = async (args) => {
+    const { tenantIds, totalRules } = args;
+    const empty = {
+        totalRules,
+        hitsToday: 0,
+        hitsWeek: 0,
+        hitsMonth: 0,
+        topRedirects: [],
+        brokenUrls: [],
+        series: daysBack(30).map((date) => ({ date, views: 0, uniques: 0 })),
+        recentLogs: [],
+    };
+    if (!tenantIds.length)
+        return empty;
+    const db = await rawDb();
+    if (!db)
+        return empty;
+    const today = utcDay();
+    const weekStart = daysBack(7)[0];
+    const monthStart = daysBack(30)[0];
+    const seriesDays = daysBack(30);
+    const [hitsToday, hitsWeek, hitsMonth, topRows, brokenRows, seriesRows, logDocs] = await Promise.all([
+        sumHits(db, tenantIds, today, today),
+        sumHits(db, tenantIds, weekStart, today),
+        sumHits(db, tenantIds, monthStart, today),
+        db
+            .collection('redirect-analytics')
+            .aggregate([
+            {
+                $match: {
+                    tenant: { $in: tenantIds },
+                    date: { $gte: monthStart },
+                    type: { $nin: ['404', '410', '451'] },
+                },
+            },
+            {
+                $group: {
+                    _id: { from: '$from', to: '$to' },
+                    hits: { $sum: '$hits' },
+                },
+            },
+            { $sort: { hits: -1 } },
+            { $limit: 8 },
+        ])
+            .toArray(),
+        db
+            .collection('redirect-analytics')
+            .aggregate([
+            {
+                $match: {
+                    tenant: { $in: tenantIds },
+                    date: { $gte: monthStart },
+                    type: { $in: ['404', '410', '451'] },
+                },
+            },
+            {
+                $group: {
+                    _id: '$from',
+                    hits: { $sum: '$hits' },
+                },
+            },
+            { $sort: { hits: -1 } },
+            { $limit: 8 },
+        ])
+            .toArray(),
+        db
+            .collection('redirect-analytics')
+            .aggregate([
+            {
+                $match: {
+                    tenant: { $in: tenantIds },
+                    date: { $gte: monthStart },
+                },
+            },
+            { $group: { _id: '$date', hits: { $sum: '$hits' } } },
+            { $sort: { _id: 1 } },
+        ])
+            .toArray(),
+        db
+            .collection('redirect-logs')
+            .aggregate([
+            { $match: { tenant: { $in: tenantIds } } },
+            { $sort: { createdAt: -1 } },
+            { $limit: 12 },
+        ])
+            .toArray(),
+    ]);
+    const byDay = new Map(seriesRows.map((r) => [String(r._id), Number(r.hits ?? 0)]));
+    return {
+        totalRules,
+        hitsToday,
+        hitsWeek,
+        hitsMonth,
+        topRedirects: topRows.map((r) => {
+            const id = r._id;
+            const from = String(id?.from ?? '');
+            const to = String(id?.to ?? '');
+            return {
+                label: to ? `${from} → ${to}` : from,
+                value: Number(r.hits ?? 0),
+            };
+        }),
+        brokenUrls: brokenRows.map((r) => ({
+            label: String(r._id ?? ''),
+            value: Number(r.hits ?? 0),
+        })),
+        series: seriesDays.map((date) => ({
+            date,
+            views: byDay.get(date) ?? 0,
+            uniques: 0,
+        })),
+        recentLogs: logDocs.map((doc, i) => {
+            const type = String(doc.type ?? '301');
+            const created = doc.createdAt;
+            return {
+                id: String(doc._id ?? i),
+                at: created instanceof Date
+                    ? created.toISOString()
+                    : typeof created === 'string'
+                        ? created
+                        : '',
+                from: String(doc.from ?? ''),
+                to: String(doc.to ?? ''),
+                type,
+                ok: doc.ok !== false && !['404', '410', '451'].includes(type),
+            };
+        }),
+    };
+};

package/dist/lib/redirects.d.ts

@@ -0,0 +1,39 @@
+import type { Payload } from 'payload';
+/**
+ * Redirect hygiene.
+ *
+ * Two failure modes kill a migration: chains (A→B→C, which bleed link equity and
+ * eventually get dropped) and cycles (A→B→A, which return a browser error). Both
+ * are cheap to prevent at write time and expensive to find later, so we resolve
+ * them when the redirect is saved rather than when it is served.
+ */
+export declare const normalisePath: (input: string) => string;
+export type ResolvedRedirect = {
+    to: string;
+    /** Every hop we collapsed, for the audit trail shown to the editor. */
+    collapsed: string[];
+};
+/**
+ * Follow the existing redirect graph from `to` and return its final destination.
+ * Throws when following it would create a cycle.
+ */
+export declare const resolveDestination: (args: {
+    payload: Payload;
+    tenantId: string;
+    from: string;
+    to: string;
+    /** Id of the redirect being saved, so it does not chase itself. */
+    selfId?: string | number;
+    maxHops?: number;
+}) => Promise<ResolvedRedirect>;
+/**
+ * Rewrite any redirect that currently points *at* `oldPath` so it points at
+ * `newPath` instead. Without this, renaming a slug twice leaves a chain behind.
+ */
+export declare const repointIncoming: (args: {
+    payload: Payload;
+    tenantId: string;
+    oldPath: string;
+    newPath: string;
+}) => Promise<number>;
+//# sourceMappingURL=redirects.d.ts.map

package/dist/lib/redirects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redirects.d.ts","sourceRoot":"","sources":["../../app/lib/redirects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAGtC;;;;;;;GAOG;AAEH,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,KAAG,MAc7C,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,uEAAuE;IACvE,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAAU,MAAM;IAC7C,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;IACV,mEAAmE;IACnE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACxB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,KAAG,OAAO,CAAC,gBAAgB,CAwC3B,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAU,MAAM;IAC1C,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB,KAAG,OAAO,CAAC,MAAM,CAyBjB,CAAA"}

package/dist/lib/redirects.js

@@ -0,0 +1,96 @@
+import { APIError } from 'payload';
+/**
+ * Redirect hygiene.
+ *
+ * Two failure modes kill a migration: chains (A→B→C, which bleed link equity and
+ * eventually get dropped) and cycles (A→B→A, which return a browser error). Both
+ * are cheap to prevent at write time and expensive to find later, so we resolve
+ * them when the redirect is saved rather than when it is served.
+ */
+export const normalisePath = (input) => {
+    const trimmed = (input ?? '').trim();
+    if (!trimmed)
+        return '/';
+    // Accept a full URL and keep only the path, so pasting from a browser works.
+    let path = trimmed;
+    try {
+        if (/^https?:\/\//i.test(trimmed))
+            path = new URL(trimmed).pathname;
+    }
+    catch {
+        /* fall through and treat it as a path */
+    }
+    if (!path.startsWith('/'))
+        path = `/${path}`;
+    path = path.replace(/\/{2,}/g, '/');
+    if (path.length > 1)
+        path = path.replace(/\/+$/, '');
+    return path;
+};
+/**
+ * Follow the existing redirect graph from `to` and return its final destination.
+ * Throws when following it would create a cycle.
+ */
+export const resolveDestination = async (args) => {
+    const { payload, tenantId, from, to, selfId, maxHops = 10 } = args;
+    const start = normalisePath(from);
+    let current = normalisePath(to);
+    const collapsed = [];
+    const seen = new Set([start]);
+    for (let hop = 0; hop < maxHops; hop += 1) {
+        if (seen.has(current)) {
+            // APIError rather than Error, so the editor sees the actual cycle in the
+            // admin UI instead of a generic "something went wrong".
+            throw new APIError(`This would create a redirect loop: ${[...seen, current].join(' → ')}. Point it at a real destination instead.`, 400);
+        }
+        seen.add(current);
+        const next = await payload.find({
+            collection: 'redirects',
+            where: {
+                and: [{ tenant: { equals: tenantId } }, { from: { equals: current } }],
+            },
+            limit: 1,
+            depth: 0,
+            pagination: false,
+        });
+        const hit = next.docs[0];
+        if (!hit || (selfId != null && String(hit.id) === String(selfId)))
+            break;
+        const nextTo = normalisePath(hit.to ?? '');
+        if (nextTo === current)
+            break;
+        collapsed.push(current);
+        current = nextTo;
+    }
+    return { to: current, collapsed };
+};
+/**
+ * Rewrite any redirect that currently points *at* `oldPath` so it points at
+ * `newPath` instead. Without this, renaming a slug twice leaves a chain behind.
+ */
+export const repointIncoming = async (args) => {
+    const { payload, tenantId, oldPath, newPath } = args;
+    const incoming = await payload.find({
+        collection: 'redirects',
+        where: {
+            and: [{ tenant: { equals: tenantId } }, { to: { equals: oldPath } }],
+        },
+        limit: 500,
+        depth: 0,
+        pagination: false,
+    });
+    let updated = 0;
+    for (const doc of incoming.docs) {
+        if (normalisePath(doc.from ?? '') === newPath)
+            continue; // would become a self-redirect
+        await payload.update({
+            collection: 'redirects',
+            id: doc.id,
+            data: { to: newPath },
+            overrideAccess: true,
+            context: { skipChainResolution: true },
+        });
+        updated += 1;
+    }
+    return updated;
+};

package/dist/lib/revalidate.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Cache tags.
+ *
+ * Publishing invalidates a small, explicit set of tags rather than the whole
+ * site — the post itself, the indexes it appears in, and the sitemap. Everything
+ * else stays warm at the edge, which is what keeps a publish from causing a
+ * traffic spike against the origin.
+ */
+export declare const tags: {
+    tenant: (tenantSlug: string) => string;
+    post: (tenantSlug: string, postSlug: string) => string;
+    postIndex: (tenantSlug: string) => string;
+    category: (tenantSlug: string, categorySlug: string) => string;
+    sitemap: (tenantSlug: string) => string;
+    redirects: (tenantSlug: string) => string;
+};
+/** Tags touched when a single post changes state. */
+export declare const tagsForPost: (args: {
+    tenantSlug: string;
+    postSlug: string;
+    categorySlugs?: string[];
+}) => string[];
+export declare const revalidateTags: (list: string[]) => void;
+/** Invalidate every public cache entry a post publish/update touches. */
+export declare const purgePublicCaches: (args: {
+    tenantSlug: string;
+    postSlug?: string;
+    categorySlugs?: string[];
+}) => Promise<void>;
+//# sourceMappingURL=revalidate.d.ts.map

package/dist/lib/revalidate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revalidate.d.ts","sourceRoot":"","sources":["../../app/lib/revalidate.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI;yBACM,MAAM;uBACR,MAAM,YAAY,MAAM;4BACnB,MAAM;2BACP,MAAM,gBAAgB,MAAM;0BAE7B,MAAM;4BACJ,MAAM;CAC/B,CAAA;AAED,qDAAqD;AACrD,eAAO,MAAM,WAAW,GAAI,MAAM;IAChC,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;CACzB,KAAG,MAAM,EAQT,CAAA;AAED,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,EAAE,KAAG,IAa/C,CAAA;AA0CD,yEAAyE;AACzE,eAAO,MAAM,iBAAiB,GAAU,MAAM;IAC5C,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;CACzB,KAAG,OAAO,CAAC,IAAI,CAaf,CAAA"}