The list is in config/redirectRules.ts (exact paths, from the old sitemap), written into dist/client by the build; check-artifact.sh requires it. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
156 lines
5.6 KiB
TypeScript
156 lines
5.6 KiB
TypeScript
// Redirects for the old WordPress addresses of andreaslop.nl (decision of
|
|
// Bryan, 2026-11-18; the inventory is aidlc-docs/features/asf-production-iis/
|
|
// oude-urls.md). The site is the source: this list is written into the build
|
|
// as redirects.json and the CMS host reads it, the same on test and on
|
|
// production. The format is the one of the host (design of SMC, 2026-11-18):
|
|
// exact paths only, no patterns; see docs/redirect-rules.md.
|
|
//
|
|
// Not in this list: the slash, case and .html variants of the real pages
|
|
// (/over-mij/ and so on; the host redirects those canonically, see
|
|
// config/canonicalUrls.ts), query-string addresses (?page_id=, decision of
|
|
// Bryan) and addresses that are a 404 anyway (/wp-admin, /wp-login.php,
|
|
// /xmlrpc.php, /wp-json, /wp-content, /category, /tag, /author, /?s=): an
|
|
// unknown path gives the 404 page without a rule.
|
|
import { pagePaths } from './canonicalUrls.ts';
|
|
|
|
export type RedirectStatus = 301 | 404 | 410;
|
|
|
|
export interface RedirectRule {
|
|
// A path with one leading slash. The host matches it case insensitive and
|
|
// with or without a slash at the end (so give it once).
|
|
from: string;
|
|
// Only for 301: a path of this site
|
|
to?: string;
|
|
status: RedirectStatus;
|
|
}
|
|
|
|
export const REDIRECT_FORMAT_VERSION = 1;
|
|
export const MAX_REDIRECTS = 5000;
|
|
|
|
// The host answers these paths itself; a rule there would never be read
|
|
const RESERVED_FIRST_SEGMENTS = ['admin', 'health', 'api'];
|
|
|
|
const permanent = (from: string, to: string): RedirectRule => ({
|
|
from,
|
|
to,
|
|
status: 301,
|
|
});
|
|
const gone = (from: string): RedirectRule => ({ from, status: 410 });
|
|
|
|
// The old sitemaps: search engines find the new one
|
|
const sitemaps = [
|
|
'/sitemap_index.xml',
|
|
'/wp-sitemap.xml',
|
|
'/page-sitemap.xml',
|
|
'/portfolio-item-sitemap.xml',
|
|
'/masonry-gallery-category-sitemap.xml',
|
|
'/portfolio-tag-sitemap.xml',
|
|
'/testimonials-category-sitemap.xml',
|
|
];
|
|
|
|
// The gallery items of the theme (from the old sitemap, 2026-11-18): the
|
|
// portfolio is the nearest page
|
|
const portfolioItems = [
|
|
'decoration',
|
|
'wedding-dress',
|
|
'best-girls',
|
|
'mm-1',
|
|
'wedding-cake',
|
|
'mm2',
|
|
'cake-smash-1',
|
|
'hairstyles',
|
|
'360',
|
|
'366',
|
|
'353',
|
|
'homepage-foto',
|
|
'getting-ready',
|
|
'm1',
|
|
'f1',
|
|
];
|
|
const portfolioTags = ['homepage', 'portfolio-gallerij', 'simple'];
|
|
|
|
export const redirectRules: readonly RedirectRule[] = [
|
|
...sitemaps.map((from) => permanent(from, '/sitemap.xml')),
|
|
permanent('/portfolio-item', '/portfolio'),
|
|
...portfolioItems.map((name) =>
|
|
permanent(`/portfolio-item/${name}`, '/portfolio'),
|
|
),
|
|
...portfolioTags.map((name) =>
|
|
permanent(`/portfolio-tag/${name}`, '/portfolio'),
|
|
),
|
|
// The theme archive of testimonials: they are on the home page
|
|
permanent('/testimonials-category/photo', '/'),
|
|
// Theme demo content and the feeds: no equivalent and no berichten
|
|
gone('/masonry-gallery-category/test-masonry-gallery'),
|
|
gone('/feed'),
|
|
gone('/comments/feed'),
|
|
];
|
|
|
|
const pathPattern = /^\/[A-Za-z0-9._~/%-]*$/;
|
|
const isPath = (value: string): boolean =>
|
|
pathPattern.test(value) && !value.startsWith('//') && !value.includes('..');
|
|
|
|
// What the host compares: lower case, without a slash at the end
|
|
const key = (path: string): string =>
|
|
path.toLowerCase().replace(/\/+$/, '') || '/';
|
|
|
|
// The reasons a rule list is not usable; empty when it is. The host validates
|
|
// the file again; the tests check this list and what is written from it.
|
|
export function redirectProblems(rules: readonly RedirectRule[]): string[] {
|
|
const problems: string[] = [];
|
|
if (rules.length > MAX_REDIRECTS) {
|
|
problems.push(`more than ${MAX_REDIRECTS} rules`);
|
|
}
|
|
const froms = new Map<string, RedirectRule>();
|
|
rules.forEach((rule, index) => {
|
|
const label = `rule ${index + 1} (${rule.from})`;
|
|
if (!isPath(rule.from) || rule.from === '/') {
|
|
problems.push(`${label}: from is not a usable path`);
|
|
return;
|
|
}
|
|
const first = key(rule.from).split('/')[1];
|
|
if (RESERVED_FIRST_SEGMENTS.includes(first)) {
|
|
problems.push(`${label}: ${first} is answered by the host itself`);
|
|
}
|
|
if (froms.has(key(rule.from))) problems.push(`${label}: duplicate`);
|
|
froms.set(key(rule.from), rule);
|
|
if (rule.status === 301) {
|
|
if (!rule.to || !isPath(rule.to)) {
|
|
problems.push(
|
|
`${label}: a 301 needs a path of this site in to`,
|
|
);
|
|
} else if (key(rule.to) === key(rule.from)) {
|
|
problems.push(`${label}: from and to are the same`);
|
|
}
|
|
} else if (rule.to !== undefined) {
|
|
problems.push(`${label}: only a 301 has a target`);
|
|
}
|
|
});
|
|
// No chains: a target is never itself a rule (the host would flatten it,
|
|
// or it is gone)
|
|
for (const rule of rules) {
|
|
if (rule.status === 301 && rule.to && froms.has(key(rule.to))) {
|
|
problems.push(
|
|
`rule ${rule.from}: the target ${rule.to} is a rule too`,
|
|
);
|
|
}
|
|
}
|
|
return problems;
|
|
}
|
|
|
|
// The pages a 301 may point to: every page of the site and the sitemap
|
|
export const redirectTargets: readonly string[] = [
|
|
...pagePaths,
|
|
'/sitemap.xml',
|
|
];
|
|
|
|
export function redirectsJson(
|
|
rules: readonly RedirectRule[] = redirectRules,
|
|
): string {
|
|
const problems = redirectProblems(rules);
|
|
if (problems.length > 0) {
|
|
throw new Error(`Invalid redirect rules:\n${problems.join('\n')}`);
|
|
}
|
|
return `${JSON.stringify({ version: REDIRECT_FORMAT_VERSION, redirects: rules }, null, 2)}\n`;
|
|
}
|