@geekity/cms 0.28.0 → 0.30.0

package/dist/web/routes.js

@@ -9,6 +9,7 @@ import { sourceVersion } from '../images/paths.js';
 import { findImageVariant, VARIANT_ASSET_PREFIX } from '../images/variants.js';
 import { ASSET_VERSION_PARAM, assetNotModified, assetRangeResponse, assetResponse, assetVersion, findThemeAsset, findUpload, IMMUTABLE_ASSET, matchesEtag, THEME_ASSET_PREFIX, UPLOAD_ASSET_MAX_AGE, UPLOAD_ASSET_PREFIX, } from './assets.js';
 import { COMMENT_NOTICE_PARAM, COMMENT_REPLY_PARAM } from '../comments/form.js';
+import { answerable, commentPolicyOf } from '../comments/policy.js';
 import { commentNoticeFor, commentReplyTarget, mountComments } from '../comments/routes.js';
 import { commenterOf } from '../comments/viewer.js';
 import { CONTACT_NOTICE_PARAM, contactNoticeFor } from '../contact/form.js';
@@ -20,8 +21,9 @@ import { advertiseIdentityEndpoints } from '../indieauth/discovery.js';
 import { publicAdminBar } from './admin-bar.js';
 import { authorFeedHref, authorContext, authorHref, authorNames, parseAuthorPath, profileContext, siteAuthorContext, } from './authors.js';
 import { feedComments, spokenIn } from './conversation.js';
-import { goneDocumentAt, isListed, isServed, permalinkOfObjectId, previewDocumentAt, publicDocumentAt, } from './documents.js';
-import { commentsFeedPath, commentsFeedResponse, feedPathUnder, feedResponse, feedSize, splitFeedPath, COMMENTS_ROOT, COMMENTS_TITLE_PREFIX, FEED_FORMATS, FEED_SEGMENTS, } from './feeds.js';
+import { COMMENT_PAGE_PREFIX } from './guids.js';
+import { goneDocumentAt, isGone, isListed, isServed, permalinkOfObjectId, previewDocumentAt, publicDocumentAt, } from './documents.js';
+import { commentsFeedPath, REPLIES_ROOT, repliesFeedPath, commentsFeedResponse, feedPathUnder, feedResponse, feedSize, splitFeedPath, COMMENTS_ROOT, COMMENTS_TITLE_PREFIX, FEED_FORMATS, FEED_SEGMENTS, } from './feeds.js';
 import { absoluteUrl, DOCUMENT_REPRESENTATIONS, documentJson, LISTING_REPRESENTATIONS, SEARCH_REPRESENTATIONS, lastModifiedOf, latestModified, MEDIA_TYPES, notAcceptableResponse, representationHref, representationEtag, representationResponse, selectRepresentation, splitRepresentationExtension, } from './negotiate.js';
 import { offsetForPage, paginate } from './pagination.js';
 import { TEMPLATES } from './render.js';
@@ -33,7 +35,7 @@ import { EMBED_PATH, embedPage, embedResponse, OEMBED_PATH, oEmbedFor, oEmbedReq
 import { generatedLlmsTxt, llmsListingTxt, LLMS_TXT_LINK, LLMS_TXT_PATH, llmsTxtResponse, ownLlmsTxt, } from './llms.js';
 import { indexNowKeyPath, indexNowKeyResponse } from './indexnow.js';
 import { searchHref, searchJson, searchPageIndex, searchQuery, SEARCH_PAGE_PARAM, SEARCH_PATH, SEARCH_QUERY_PARAM, } from './search.js';
-import { findQueryRedirect, redirectLocation } from './redirects.js';
+import { findPathRedirect, findQueryRedirect, redirectLocation } from './redirects.js';
 import { PAGE_SEGMENT, redirectedTerm, taxonomyForSegment, termHref } from './taxonomy.js';
 /**
  * Register the public site on a Hono app.
@@ -114,6 +116,11 @@ export function mountPublicSite(app) {
     }
     // The site-wide comments feed, for the same reason and at WordPress's URL.
     app.get(commentsFeedHref(undefined), (c) => comments(c, undefined));
+    // A native comment's own page (TASK-318), at a fixed path so a permalink
+    // cannot take it.
+    app.get(`${COMMENT_PAGE_PREFIX}:id/`, (c) => commentPage(c, c.req.param('id')));
+    // The feed of one item's direct replies (TASK-324), fixed for the same reason.
+    app.get(`${REPLIES_ROOT}:segment/`, (c) => repliesFeed(c, c.req.param('segment')));
     // The sitemap, its children and the robots file: fixed paths at the root of
     // the site, which is the only place a crawler looks, and routes for the same
     // reason the feeds are — no document permalinked there can take the URL a
@@ -292,12 +299,12 @@ function resolveRequest(c) {
             return listing(c, request);
         }
     }
-    const feedRequest = parseFeedPath(store, pathname, bases, authors);
+    const feedRequest = parseFeedPath(c, pathname, bases, authors);
     if (feedRequest !== undefined) {
         const { target, format } = feedRequest;
         const canonical = feedTargetHref(target, format, bases);
         if (!feedRequest.canonical ||
-            isCarriedTagFeedInAnotherCasing(store, target, canonical, pathname)) {
+            (target.kind === 'listing' && canonical !== encodePath(pathname))) {
             return c.redirect(canonical, 301);
         }
         return target.kind === 'listing'
@@ -321,11 +328,11 @@ function resolveRequest(c) {
         // is the front page.
         if (document.path === pages.home?.path)
             return c.redirect('/', 301);
-        // WordPress answered `?feed=rss2` on a permalink with that post's comments
-        // feed, which is the only feed a post has here too. The other spellings
-        // name a format a comments feed does not come in, so they are not a feed
-        // request at all and the page is served.
-        if (document.type === 'post' && queryFeedFormat(c) === 'rss') {
+        // WordPress answered `?feed=rss2` on a permalink with that document's
+        // comments feed, which is the only feed a document has here too. The other
+        // spellings name a format a comments feed does not come in, so they are
+        // not a feed request at all and the page is served.
+        if (queryFeedFormat(c) === 'rss' && showsConversation(c, document)) {
             return c.redirect(commentsFeedHref(document), 301);
         }
         return negotiateDocument(c, document, selectFromAccept(c, DOCUMENT_REPRESENTATIONS));
@@ -370,11 +377,13 @@ function resolveRequest(c) {
     }
     // Nothing lives here, so a URL something used to live at leads on to where
     // it lives now. Asked only after every live lookup, which is what lets a new
-    // document take an old URL over.
+    // document take an old URL over, and a term that comes back into use beat
+    // the record of what it was renamed to.
     const formerly = movedHref(store, pages, pathname, undefined) ??
         extension?.paths
             .map((candidate) => movedHref(store, pages, candidate, extension.representation))
-            .find((href) => href !== undefined);
+            .find((href) => href !== undefined) ??
+        renamedTermHref(c, pathname, bases);
     if (formerly !== undefined)
         return c.redirect(`${formerly}${search}`, 301);
     const deleted = [pathname, ...(extension?.paths ?? [])].some((candidate) => goneDocumentAt(store, candidate) !== undefined);
@@ -385,10 +394,8 @@ function resolveRequest(c) {
         return c.redirect(canonical, 301);
     // And a URL the site itself says has moved (TASK-128), after every live
     // lookup and after the slash that would lead to one, so a declared source
-    // never shadows a live document. One asked for without its trailing slash
-    // reaches the target in one hop.
-    const declared = c.var.redirects.current().paths;
-    const redirect = declared.get(pathname) ?? (pathname.endsWith('/') ? undefined : declared.get(`${pathname}/`));
+    // never shadows a live document.
+    const redirect = findPathRedirect(c.var.redirects.current(), pathname);
     if (redirect !== undefined) {
         return c.redirect(redirectLocation(redirect, search), redirect.status);
     }
@@ -411,9 +418,10 @@ function movedHref(store, pages, pathname, representation) {
  * `undefined` when the path is not one.
  *
  * `/{base}/x/page/1/` collapses onto the archive root the way `/page/1/`
- * collapses onto the home page, and an archive nothing carries 404s rather
- * than redirecting first: a URL that leads nowhere should cost one 404, not a
- * redirect and then a 404.
+ * collapses onto the home page, and any other casing of a term collapses onto
+ * the site's spelling of it (TASK-339). A term nothing carries is not an
+ * archive at all, so the request goes on to the renames and the declared
+ * redirects that may know where it went.
  */
 function taxonomyArchive(c, pathname, bases, authors) {
     if (!pathname.endsWith('/'))
@@ -421,18 +429,9 @@ function taxonomyArchive(c, pathname, bases, authors) {
     const request = parseListingPath(c.var.store, pathname, bases, authors);
     if (request?.term === undefined)
         return undefined;
-    // An archive that answers is served; only once nothing carries the term is
-    // the record of renames consulted, so a term that comes back into use — or
-    // one that was merged into and then recreated — beats what it used to be
-    // called. One hop: the list is stored with its chains already collapsed.
-    if (countListing(c.var.store, request) === 0) {
-        const moved = movedTerm(c, request.term);
-        if (moved !== undefined)
-            return c.redirect(termHref(moved, request.pageNumber, bases), 301);
-    }
     const canonical = termHref(request.term, request.pageNumber, bases);
     if (canonical !== encodePath(pathname)) {
-        return countListing(c.var.store, request) === 0 ? notFound(c) : c.redirect(canonical, 301);
+        return c.redirect(`${canonical}${new URL(c.req.url).search}`, 301);
     }
     return listing(c, request);
 }
@@ -471,12 +470,25 @@ function authorArchive(c, pathname, bases, authors) {
     return listing(c, request);
 }
 /**
- * Where a term with nothing left under it went, or `undefined` when the site
- * records no such rename.
+ * Where a renamed term's archive page or feed lives now, or `undefined` when
+ * the path is neither or the site records no rename of its term.
+ *
+ * One hop: the list is stored with its chains already collapsed. A subscriber
+ * to the old feed follows it to the new one, exactly as a reader of the archive
+ * does.
  */
-function movedTerm(c, term) {
-    const moved = redirectedTerm(c.var.renderer.termRedirects(), term);
-    return moved === undefined ? undefined : { taxonomy: term.taxonomy, term: moved };
+function renamedTermHref(c, pathname, bases) {
+    const feedPath = splitFeedPath(pathname);
+    const asked = parseTermPath(feedPath?.root ?? pathname, bases);
+    if (asked === undefined || (feedPath !== undefined && asked.pageNumber !== 0))
+        return undefined;
+    const to = redirectedTerm(c.var.renderer.termRedirects(), asked.term);
+    if (to === undefined)
+        return undefined;
+    const moved = { taxonomy: asked.term.taxonomy, term: to };
+    return feedPath === undefined
+        ? termHref(moved, asked.pageNumber, bases)
+        : feedHref(moved, feedPath.format, bases);
 }
 /**
  * A path as the feed it names: `/feed/`, `/feed/atom/`, `/{base}/x/feed/json/`,
@@ -485,9 +497,10 @@ function movedTerm(c, term) {
  *
  * The site's own canonical feeds are real routes and never reach here; what
  * does reach here is every taxonomy feed — their bases are a setting, so they
- * cannot be in the route table — every post's comments feed, and every alias.
+ * cannot be in the route table — every document's comments feed, and every alias.
  */
-function parseFeedPath(store, pathname, bases, authors) {
+function parseFeedPath(c, pathname, bases, authors) {
+    const { store } = c.var;
     const split = splitFeedPath(pathname);
     if (split === undefined)
         return undefined;
@@ -505,16 +518,19 @@ function parseFeedPath(store, pathname, bases, authors) {
             ? { target: { kind: 'listing', subject: root }, format, canonical }
             : undefined;
     }
-    // Otherwise it may be a post's comments feed. Only a published post has one:
-    // a page never federates, so nothing in the fediverse can ever have replied
-    // to it, and a comments feed for it would be empty for ever.
+    // Otherwise it may be a document's comments feed, which it has exactly when
+    // its page shows its conversation.
     if (format !== 'rss')
         return undefined;
     const document = publicDocumentAt(store, split.root);
-    if (document?.type !== 'post')
+    if (document === undefined || !showsConversation(c, document))
         return undefined;
     return { target: { kind: 'comments', document }, format, canonical };
 }
+/** Whether this document's page shows its conversation, and so has a comments feed. */
+function showsConversation(c, document) {
+    return answerable(document, commentPolicyOf(c.var.renderer.site()), c.var.store.now());
+}
 /** Where the canonical URL of one feed is. */
 function feedTargetHref(target, format, bases) {
     return target.kind === 'listing'
@@ -543,7 +559,7 @@ function queryFeedFormat(c) {
  * URL and is read back here. An unknown value says nothing at all rather than
  * being printed, so the query cannot be used to put words on somebody's post.
  */
-function commentNotice(c, document) {
+function commentNotice(c, document, viewer) {
     const notice = commentNoticeFor(c.req.query(COMMENT_NOTICE_PARAM));
     return {
         ...(notice === undefined ? {} : { commentNotice: notice }),
@@ -554,6 +570,7 @@ function commentNotice(c, document) {
             admin: c.var.admin,
             document,
             id: c.req.query(COMMENT_REPLY_PARAM),
+            thread: viewer === undefined ? undefined : c.var.conversation.thread(document),
         }),
         // And the thank-you after a contact form was sent, which travels the same
         // way for the same reason (TASK-56).
@@ -602,7 +619,7 @@ function negotiateDocument(c, document, representation, href = document.permalin
     const page = representation === 'html'
         ? c.var.renderer.renderPage(document, {
             frontPage: href === '/',
-            extra: { ...commentNotice(c, document), ...(listed ? {} : { noindex: true }) },
+            extra: { ...commentNotice(c, document, viewer), ...(listed ? {} : { noindex: true }) },
             viewer,
         })
         : undefined;
@@ -689,17 +706,11 @@ function canonicalPath(c, pathname, bases, authors) {
 function canonicalTarget(c, pathname, bases, authors) {
     const { store, renderer } = c.var;
     // A feed first: `/feed`, `/feed/atom`, `/{base}/x/feed`, `/comments/feed`
-    // and a post's `{permalink}feed` all lead somewhere real, and `/feed/rss`
+    // and a document's `{permalink}feed` all lead somewhere real, and `/feed/rss`
     // leads to `/feed/` in the same one hop rather than to a second redirect.
-    const feedRequest = parseFeedPath(store, pathname, bases, authors);
+    const feedRequest = parseFeedPath(c, pathname, bases, authors);
     if (feedRequest !== undefined) {
-        const { target } = feedRequest;
-        if (target.kind === 'listing' &&
-            target.subject.term !== undefined &&
-            countListing(store, target.subject) === 0) {
-            return undefined;
-        }
-        return feedTargetHref(target, feedRequest.format, bases);
+        return feedTargetHref(feedRequest.target, feedRequest.format, bases);
     }
     const pages = frontPages(c);
     const document = store.getByPermalink(pathname);
@@ -716,11 +727,7 @@ function canonicalTarget(c, pathname, bases, authors) {
     const listing = listingRequestAt(store, pages, pathname, bases, authors);
     if (listing === undefined)
         return undefined;
-    // The home listing and an author archive both exist with nothing on them; a
-    // taxonomy archive does not.
     const total = countListing(store, listing);
-    if (listing.term !== undefined && total === 0)
-        return undefined;
     const totalPages = Math.max(1, Math.ceil(total / renderer.pageSize()));
     if (listing.pageNumber >= totalPages)
         return undefined;
@@ -847,11 +854,27 @@ function parseListingPath(store, pathname, bases, authors) {
         const found = authors(byAuthor.username);
         return found === undefined ? undefined : { author: found, pageNumber: byAuthor.pageNumber };
     }
+    // A taxonomy archive exists only while a published post carries the term,
+    // so a term nothing carries is not a listing, whatever its path says.
+    const asked = parseTermPath(pathname, bases);
+    if (asked === undefined)
+        return undefined;
+    const spelled = carriedSpelling(store, asked.term);
+    return spelled === undefined
+        ? undefined
+        : { term: { ...asked.term, term: spelled }, pageNumber: asked.pageNumber };
+}
+/**
+ * `/{base}/x/` and `/{base}/x/page/N/` as the term and page they name, as the
+ * path spells them, whether or not anything carries the term.
+ */
+function parseTermPath(pathname, bases) {
+    const segments = pathname.split('/').filter((segment) => segment !== '');
     const taxonomy = taxonomyForSegment(segments[0], bases);
     const named = segments[1];
     if (taxonomy === undefined || named === undefined)
         return undefined;
-    const term = { taxonomy, term: asTheSiteSpellsIt(store, taxonomy, named) };
+    const term = { taxonomy, term: named };
     if (segments.length === 2)
         return { term, pageNumber: 0 };
     if (segments.length === 4 && segments[2] === PAGE_SEGMENT) {
@@ -860,14 +883,23 @@ function parseListingPath(store, pathname, bases, authors) {
     }
     return undefined;
 }
-function asTheSiteSpellsIt(store, taxonomy, term) {
-    return taxonomy === 'tag' ? (store.tagSpelling(term) ?? term) : term;
-}
-function isCarriedTagFeedInAnotherCasing(store, target, canonical, pathname) {
-    return (target.kind === 'listing' &&
-        target.subject.term?.taxonomy === 'tag' &&
-        canonical !== encodePath(pathname) &&
-        countListing(store, target.subject) > 0);
+/**
+ * How the site spells a term some published post carries, matched without
+ * regard to case, or `undefined` when none carries it (TASK-339).
+ *
+ * A tag's casings are one term (TASK-308). A category stays as spelled, so a
+ * category carried in exactly the asked spelling wins, and otherwise the most
+ * used one that differs only in case: WordPress lower-cased every slug, so an
+ * imported `/category/rsscloud/` names the category spelled `rssCloud`.
+ */
+function carriedSpelling(store, term) {
+    if (term.taxonomy === 'tag') {
+        return store.countByTag(term.term) > 0 ? store.tagSpelling(term.term) : undefined;
+    }
+    if (store.countByCategory(term.term) > 0)
+        return term.term;
+    const key = term.term.toLowerCase();
+    return store.listCategories().find(({ category }) => category.toLowerCase() === key)?.category;
 }
 /** How many published documents a listing holds. */
 function countListing(store, subject) {
@@ -940,11 +972,7 @@ function listing(c, request, representation = selectFromAccept(c, LISTING_REPRES
     const asked = queryFeedFormat(c);
     if (asked !== undefined)
         return c.redirect(listingFeedHref(request, asked, bases), 301);
-    // A taxonomy archive only exists while something carries the term; the home
-    // listing and a person's archive exist even with nothing on them.
     const total = countListing(store, request);
-    if (term !== undefined && total === 0)
-        return notFound(c);
     const href = listingHref(request, request.pageNumber, bases, root);
     const pagination = paginate({
         total,
@@ -1123,14 +1151,6 @@ function feed(c, format, subject) {
     const site = renderer.site();
     const bases = renderer.taxonomyBases();
     const { term, author } = subject;
-    if (term !== undefined && countListing(store, subject) === 0) {
-        // A subscriber to a renamed archive's feed follows it to the new one
-        // rather than being dropped, exactly as a reader of the archive does.
-        const moved = movedTerm(c, term);
-        if (moved === undefined)
-            return notFound(c);
-        return c.redirect(feedHref(moved, format, bases), 301);
-    }
     const documents = listListing(store, subject, { limit: feedSize(site) });
     const href = listingHref(subject, 0, bases);
     // What the feed calls itself: the site, and then the term or the person it
@@ -1155,12 +1175,11 @@ function feed(c, format, subject) {
     return feedResponse({ format, source, conditional: conditionalHeaders(c) });
 }
 /**
- * A post's comments, or the whole site's, as RSS 2.0.
+ * A post's or page's comments, or the whole site's, as RSS 2.0.
  *
- * A post with no replies answers an empty feed rather than a 404: it exists,
- * and a reader that subscribed before anybody answered should keep polling.
- * Only a permalink that is no published post 404s, which is the ordinary
- * document lookup rather than anything this feed decides.
+ * A document with no replies answers an empty feed rather than a 404: it
+ * exists, and a reader that subscribed before anybody answered should keep
+ * polling. Which documents have a feed at all is {@link parseFeedPath}'s to say.
  */
 function comments(c, document) {
     const { conversation, renderer, config } = c.var;
@@ -1171,7 +1190,12 @@ function comments(c, document) {
     // looking at one conversation. A post's own feed hands the builder entries
     // with no post attached, and so its items name no post: there, every item
     // answers the same one.
-    const found = feedComments(document === undefined ? conversation.latest(limit) : spokenIn(conversation.thread(document)), { baseUrl: config.baseUrl, limit, cited: (url) => c.var.replyContexts.read(url) });
+    const found = feedComments(document === undefined ? conversation.latest(limit) : spokenIn(conversation.thread(document)), {
+        baseUrl: config.baseUrl,
+        limit,
+        cited: (url) => c.var.replyContexts.read(url),
+        post: document,
+    });
     const source = {
         site,
         comments: found,
@@ -1184,6 +1208,55 @@ function comments(c, document) {
     };
     return commentsFeedResponse(source, conditionalHeaders(c));
 }
+/**
+ * The feed of one item's direct replies (TASK-324): a post's or page's, or a
+ * reply's, so a reader can walk a thread one level at a time through
+ * `source:comments`. An item nobody answered has an empty feed; a segment
+ * naming nothing a reader can see 404s, as does one on a document not showing
+ * its conversation, by the rule `{permalink}feed/` follows.
+ */
+function repliesFeed(c, segment) {
+    const { conversation, renderer, config } = c.var;
+    const found = conversation.repliesTo(segment);
+    if (found === undefined || !showsConversation(c, found.post))
+        return notFound(c);
+    const site = renderer.site();
+    const cited = (url) => c.var.replyContexts.read(url);
+    const label = postLabel(found.post, cited);
+    const source = {
+        site,
+        comments: feedComments(found.replies, {
+            baseUrl: config.baseUrl,
+            limit: feedSize(site),
+            cited,
+            post: found.post,
+        }),
+        title: found.reply === null
+            ? `Replies to: ${label}`
+            : `Replies to ${found.reply.author.name} on ${label}`,
+        href: found.reply?.url ?? found.post.permalink,
+        feedHref: repliesFeedPath(segment),
+        baseUrl: config.baseUrl,
+    };
+    return commentsFeedResponse(source, conditionalHeaders(c));
+}
+/**
+ * One native comment on a page of its own (TASK-318), answering as its post
+ * would: 410 once the post is deleted, and 404 while it is not served or not
+ * showing its conversation. It is never listed anywhere, so it is noindex.
+ */
+function commentPage(c, id) {
+    const { conversation, renderer, store } = c.var;
+    const found = conversation.comment(id);
+    if (found === undefined)
+        return notFound(c);
+    const now = store.now();
+    if (isGone(found.post, now))
+        return gone(c);
+    if (!isServed(found.post, now) || !showsConversation(c, found.post))
+        return notFound(c);
+    return c.html(renderer.renderComment(found), 200, { 'x-robots-tag': 'noindex' });
+}
 /**
  * The sitemap, or one of its children once the site is too big for one file.
  *
@@ -1447,10 +1520,10 @@ export function feedHref(term, format, bases) {
     return feedPathUnder(listingHref({ term }, 0, bases), format);
 }
 /**
- * Where the site's comments feed lives, and where one post's does.
+ * Where the site's comments feed lives, and where one document's does.
  *
  * WordPress's URLs, so a site migrated from it keeps both: the whole site's
- * comments at `/comments/feed/`, and a post's under its own permalink. There
+ * comments at `/comments/feed/`, and a document's under its own permalink. There
  * is one format, RSS 2.0, because that is what a comments feed is read in.
  */
 export function commentsFeedHref(document) {