@nialto-services/astro-site-checks 0.1.1 → 0.2.0

package/README.md

@@ -36,6 +36,9 @@ target is listed once, with up to five of the pages that link to it.
 A link to the source of a redirect is a warning rather than a failure: it resolves, but through a 301, so it
 is worth linking straight to the destination.
 
+A page that renders on demand (a file in `src/pages` exporting `prerender = false`) counts as served, since
+the build writes no file for it.
+
 Links to other hosts, including protocol-relative ones (`//cdn.example.com/…`), `mailto:` and `tel:` links,
 in-page anchors and absolute links back to the site's own host are not checked.
 
@@ -49,6 +52,9 @@ Checks every rule in the built `_redirects` for four faults:
 - a page rule without its other trailing-slash spelling pointing at the same target. Cloudflare matches a
   rule's source exactly, so without both spellings one of them lands on a 404.
 
+A target served by a page that renders on demand counts as served, and a rule that only adds or removes the
+trailing slash on a page's own URL is not asked for its other spelling.
+
 A placeholder (`:name`, `*`) or a target on another host is skipped only by the faults that would have to
 resolve it: a placeholder rule's concrete target is still checked, and so is the source of a rule pointing at
 another host. A site with no `_redirects` passes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nialto-services/astro-site-checks",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Post-build checks for Nialto's Astro sites: internal links, redirects, scoped CSS and the Content-Security-Policy.",
   "license": "MIT",
   "type": "module",

package/src/checks/links.mjs

@@ -16,6 +16,7 @@ import {
   isServable,
   servedPathOf
 } from '../built-site.mjs'
+import { collectOnDemandRoutes, isOnDemand } from '../on-demand.mjs'
 import { parseRedirects } from '../redirects.mjs'
 import { readOptionalFile, requireBuiltSite } from './built.mjs'
 
@@ -49,11 +50,12 @@ function listFindings(grouped, describeTarget, write) {
   }
 }
 
-export async function checkLinks({ clientDirectory, report }) {
+export async function checkLinks({ clientDirectory, siteDirectory, report }) {
   if (!(await requireBuiltSite(clientDirectory, report))) return false
 
   const redirects = parseRedirects((await readOptionalFile(join(clientDirectory, '_redirects'))) ?? '')
   const servablePaths = await collectServablePaths(clientDirectory)
+  const onDemandRoutes = await collectOnDemandRoutes(siteDirectory)
   const pages = (await collectBuiltFiles(clientDirectory)).filter((file) => file.endsWith('.html'))
 
   const broken = []
@@ -68,7 +70,7 @@ export async function checkLinks({ clientDirectory, report }) {
         continue
       }
 
-      if (isServable(servablePaths, path)) continue
+      if (isServable(servablePaths, path) || isOnDemand(onDemandRoutes, path)) continue
 
       broken.push({ from, path })
     }

package/src/checks/redirects.mjs

@@ -7,6 +7,7 @@
  */
 import { join } from 'node:path'
 import { collectServablePaths } from '../built-site.mjs'
+import { collectOnDemandRoutes, isOnDemand } from '../on-demand.mjs'
 import {
   findBrokenTargets,
   findMissingSpellings,
@@ -26,7 +27,7 @@ function reportFaults(report, heading, faults, describe, remedy) {
   return true
 }
 
-export async function checkRedirects({ clientDirectory, report }) {
+export async function checkRedirects({ clientDirectory, siteDirectory, report }) {
   if (!(await requireBuiltSite(clientDirectory, report))) return false
 
   const text = await readOptionalFile(join(clientDirectory, '_redirects'))
@@ -37,12 +38,13 @@ export async function checkRedirects({ clientDirectory, report }) {
 
   const redirects = parseRedirects(text)
   const servablePaths = await collectServablePaths(clientDirectory)
+  const onDemandRoutes = await collectOnDemandRoutes(siteDirectory)
 
   const failures = [
     reportFaults(
       report,
       'Redirects pointing at a path the build does not serve',
-      findBrokenTargets(redirects, servablePaths),
+      findBrokenTargets(redirects, servablePaths, (path) => isOnDemand(onDemandRoutes, path)),
       ({ source, target }) => `${source} -> ${target}`,
       'Point the rule at a page that exists, or drop it if the destination has gone for good.'
     ),

package/src/index.mjs

@@ -11,6 +11,7 @@ export { checkHeaders } from './checks/headers.mjs'
 export { checkLinks } from './checks/links.mjs'
 export { checkRedirects } from './checks/redirects.mjs'
 export { readConfig } from './config.mjs'
+export { collectOnDemandRoutes, isOnDemand } from './on-demand.mjs'
 export { extractLoadedOrigins, findPolicyViolations, originAllowedBy, parsePolicy } from './csp.mjs'
 export {
   findBrokenTargets,

package/src/on-demand.mjs

@@ -0,0 +1,58 @@
+/**
+ * Routes a site renders on demand (`export const prerender = false`). The build writes no file for them,
+ * so without this a link or redirect to one looks broken. Read from `src/pages` because the Cloudflare
+ * adapter leaves no route list in the built output.
+ */
+import { readdir, readFile } from 'node:fs/promises'
+import { join, relative } from 'node:path'
+
+const PAGE_EXTENSION_PATTERN = /\.(astro|ts|js|mjs)$/
+const ON_DEMAND_PATTERN = /export\s+const\s+prerender\s*=\s*false/
+
+async function collectPageFiles(directory) {
+  const entries = await readdir(directory, { withFileTypes: true }).catch(() => [])
+  const files = await Promise.all(
+    entries.map((entry) => {
+      const path = join(directory, entry.name)
+      if (entry.isDirectory()) return collectPageFiles(path)
+
+      return PAGE_EXTENSION_PATTERN.test(entry.name) ? [path] : []
+    })
+  )
+
+  return files.flat()
+}
+
+/** A page file's route as a pattern matching its path with or without a trailing slash. */
+function routePattern(pagesDirectory, file) {
+  const route = relative(pagesDirectory, file)
+    .replace(PAGE_EXTENSION_PATTERN, '')
+    .replace(/(^|\/)index$/, '')
+    .split('/')
+    .filter(Boolean)
+    .map((segment) => {
+      if (/^\[\.\.\..+\]$/.test(segment)) return '.*'
+      if (/^\[.+\]$/.test(segment)) return '[^/]+'
+
+      return segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    })
+    .join('/')
+
+  return new RegExp(`^/${route}${route ? '/?' : ''}$`)
+}
+
+/** A pattern for every page under the site's `src/pages` that renders on demand. */
+export async function collectOnDemandRoutes(siteDirectory) {
+  const pagesDirectory = join(siteDirectory, 'src', 'pages')
+  const routes = []
+  for (const file of await collectPageFiles(pagesDirectory)) {
+    if (ON_DEMAND_PATTERN.test(await readFile(file, 'utf-8'))) routes.push(routePattern(pagesDirectory, file))
+  }
+
+  return routes
+}
+
+/** Whether a path is served by a page rendered on demand. */
+export function isOnDemand(routes, path) {
+  return routes.some((route) => route.test(path))
+}

package/src/redirects.mjs

@@ -37,11 +37,11 @@ function isConcretePath(path) {
  * A 301 to a missing page is worse than no rule at all: a crawler follows it, finds nothing, and drops the
  * old URL without gaining a replacement.
  */
-export function findBrokenTargets(redirects, servablePaths) {
+export function findBrokenTargets(redirects, servablePaths, isAlsoServed = () => false) {
   const broken = []
   for (const [source, target] of redirects) {
     if (!isConcretePath(target)) continue
-    if (isServable(servablePaths, target)) continue
+    if (isServable(servablePaths, target) || isAlsoServed(target)) continue
 
     broken.push({ source, target })
   }
@@ -104,7 +104,10 @@ export function findMissingSpellings(redirects) {
     if (source === '/' || lastSegment.includes('.')) continue
 
     const otherSpelling = source.endsWith('/') ? source.slice(0, -1) : `${source}/`
-    if (redirects.get(otherSpelling) === target) continue
+
+    // A rule adding or removing the slash on a page's own URL has no other spelling to add: that one
+    // would redirect to itself.
+    if (otherSpelling === target || redirects.get(otherSpelling) === target) continue
 
     missing.push({ source, missing: otherSpelling, target })
   }