arcway 0.4.18 → 0.4.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcway",
-  "version": "0.4.18",
+  "version": "0.4.19",
   "description": "A convention-based framework for building modular monoliths with strict domain boundaries.",
   "license": "MIT",
   "type": "module",

package/server/config/modules/pages.js

@@ -12,6 +12,77 @@ const DEFAULTS = {
 };
 
 const HMR_KEYS = new Set(['protocol', 'host', 'clientPort']);
+const REWRITE_TOKEN = /:([A-Za-z][A-Za-z0-9]*)(\*)?/g;
+
+function rewritePrefix(destination) {
+  const tokenIndex = destination.indexOf(':');
+  return destination.slice(0, tokenIndex < 0 ? destination.length : tokenIndex).replace(/\/$/, '');
+}
+
+function validRewritePath(value) {
+  return typeof value === 'string' && value.startsWith('/') && !/[?#\s]/.test(value);
+}
+
+function validateRewriteRules(rules) {
+  if (rules.length === 0) throw new TypeError('Invalid config: pages.rewrite must not be empty');
+  for (const rule of rules) {
+    if (!rule || typeof rule !== 'object' || Array.isArray(rule)) {
+      throw new TypeError('Invalid config: each pages.rewrite rule must be an object');
+    }
+    if (!validRewritePath(rule.source) || !validRewritePath(rule.destination)) {
+      throw new TypeError(
+        'Invalid config: each pages.rewrite rule requires absolute source and destination paths',
+      );
+    }
+    const sourceSegments = rule.source.split('/').slice(1);
+    for (const [index, segment] of sourceSegments.entries()) {
+      if (segment.includes(':') && !/^:[A-Za-z][A-Za-z0-9]*\*?$/.test(segment)) {
+        throw new TypeError(
+          'Invalid config: pages.rewrite source tokens must occupy a path segment',
+        );
+      }
+      if (segment.endsWith('*') && index !== sourceSegments.length - 1) {
+        throw new TypeError('Invalid config: a pages.rewrite catch-all token must be last');
+      }
+    }
+    const sourceTokens = new Set([...rule.source.matchAll(REWRITE_TOKEN)].map((match) => match[1]));
+    for (const match of rule.destination.matchAll(REWRITE_TOKEN)) {
+      if (match[1] !== 'host' && !sourceTokens.has(match[1])) {
+        throw new TypeError(`Invalid config: unknown pages.rewrite token :${match[1]}`);
+      }
+    }
+    if (rule.destination.replace(REWRITE_TOKEN, '').includes(':')) {
+      throw new TypeError('Invalid config: pages.rewrite destination contains an invalid token');
+    }
+    const prefix = rewritePrefix(rule.destination);
+    if (prefix === '' || prefix === '/' || !validRewritePath(prefix)) {
+      throw new TypeError(
+        'Invalid config: pages.rewrite destination needs a static internal prefix',
+      );
+    }
+    if (rule.host != null) {
+      if (!rule.host || typeof rule.host !== 'object' || Array.isArray(rule.host)) {
+        throw new TypeError('Invalid config: pages.rewrite host must be an object');
+      }
+      for (const key of Object.keys(rule.host)) {
+        if (!['include', 'exclude'].includes(key)) {
+          throw new TypeError(`Invalid config: pages.rewrite host.${key} is not supported`);
+        }
+      }
+      for (const key of ['include', 'exclude']) {
+        if (
+          rule.host[key] != null &&
+          (!Array.isArray(rule.host[key]) ||
+            rule.host[key].some((host) => typeof host !== 'string' || host.length === 0))
+        ) {
+          throw new TypeError(
+            `Invalid config: pages.rewrite host.${key} must be an array of hosts`,
+          );
+        }
+      }
+    }
+  }
+}
 
 function resolveHmr(rawHmr) {
   if (rawHmr == null) return undefined;
@@ -80,9 +151,10 @@ function resolve(config, { rootDir } = {}) {
     throw new TypeError('Invalid config: pages.language must be a valid language tag');
   }
   if (pages.rewrite != null) {
-    if (
+    if (Array.isArray(pages.rewrite)) {
+      validateRewriteRules(pages.rewrite);
+    } else if (
       typeof pages.rewrite !== 'object' ||
-      Array.isArray(pages.rewrite) ||
       typeof pages.rewrite.handler !== 'function' ||
       typeof pages.rewrite.reservedPrefix !== 'string' ||
       pages.rewrite.reservedPrefix === '/' ||
@@ -91,7 +163,7 @@ function resolve(config, { rootDir } = {}) {
       /[?#\s]/.test(pages.rewrite.reservedPrefix)
     ) {
       throw new TypeError(
-        'Invalid config: pages.rewrite requires a handler function and a reservedPrefix such as "/_sites"',
+        'Invalid config: pages.rewrite requires an array of static rules or a handler function with a reservedPrefix',
       );
     }
   }

package/server/pages/handler.js

@@ -37,6 +37,7 @@ function createPagesHandler(options) {
   const appContext = options.appContext ?? null;
   const documentLanguage = options.documentLanguage;
   const rewrite = options.rewrite ?? null;
+  const reservedPrefixes = getRewriteReservedPrefixes(rewrite);
   const mode = options.mode ?? 'production';
   const devMode = mode === 'development';
   const viteDev = options.viteDev === true;
@@ -61,7 +62,7 @@ function createPagesHandler(options) {
     rootDir,
     outDir,
     viteDev,
-    reservedPrefix: rewrite?.reservedPrefix,
+    reservedPrefixes,
   });
   let lastSeenVersion = lazyContext ? manifest.version : 0;
   const componentCache = new Map();
@@ -87,7 +88,7 @@ function createPagesHandler(options) {
       rootDir,
       outDir,
       viteDev,
-      reservedPrefix: rewrite?.reservedPrefix,
+      reservedPrefixes,
     });
     componentCache.clear();
     cacheVersion++;
@@ -116,7 +117,7 @@ function createPagesHandler(options) {
       rootDir,
       outDir,
       viteDev,
-      reservedPrefix: rewrite?.reservedPrefix,
+      reservedPrefixes,
     });
     componentCache.clear();
     cacheVersion++;
@@ -508,6 +509,7 @@ function normalizeHost(value) {
 
 async function resolvePageRewrite(rewrite, ctx) {
   if (!rewrite) return { pathname: ctx.page.pathname };
+  if (Array.isArray(rewrite)) return resolveStaticPageRewrite(rewrite, ctx);
   const { reservedPrefix, handler } = rewrite;
   if (
     !ctx.page.host ||
@@ -529,6 +531,88 @@ async function resolvePageRewrite(rewrite, ctx) {
   return { pathname: result.pathname };
 }
 
+function getRewriteReservedPrefixes(rewrite) {
+  if (!rewrite) return [];
+  if (!Array.isArray(rewrite)) return [rewrite.reservedPrefix];
+  return [
+    ...new Set(
+      rewrite.map(({ destination }) => {
+        const tokenIndex = destination.indexOf(':');
+        return destination
+          .slice(0, tokenIndex < 0 ? destination.length : tokenIndex)
+          .replace(/\/$/, '');
+      }),
+    ),
+  ];
+}
+
+function isReservedPath(pathname, reservedPrefixes) {
+  return reservedPrefixes.some(
+    (prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`),
+  );
+}
+
+function normalizeConfiguredHost(host) {
+  return normalizeHost(host);
+}
+
+function matchesRewriteHost(host, condition) {
+  if (!condition) return true;
+  const includes = condition.include?.map(normalizeConfiguredHost);
+  const excludes = condition.exclude?.map(normalizeConfiguredHost);
+  if (includes && !includes.includes(host)) return false;
+  return !excludes?.includes(host);
+}
+
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function matchRewriteSource(source, pathname) {
+  const names = [];
+  const segments = source.split('/').slice(1);
+  let pattern = '^';
+  for (const [index, segment] of segments.entries()) {
+    const token = segment.match(/^:([A-Za-z][A-Za-z0-9]*)(\*)?$/);
+    if (!token) {
+      pattern += `/${escapeRegex(segment)}`;
+      continue;
+    }
+    names.push(token[1]);
+    if (token[2]) {
+      pattern += index === segments.length - 1 ? '(?:/(.*))?' : '/(.*)';
+    } else {
+      pattern += '/([^/]+)';
+    }
+  }
+  const match = pathname.match(new RegExp(`${pattern}/?$`));
+  if (!match) return null;
+  return Object.fromEntries(names.map((name, index) => [name, match[index + 1] ?? '']));
+}
+
+function interpolateRewriteDestination(destination, host, params) {
+  return destination.replace(/:([A-Za-z][A-Za-z0-9]*)(\*)?/g, (_match, name) => {
+    if (name === 'host') return encodeURIComponent(host);
+    return params[name] ?? '';
+  });
+}
+
+function resolveStaticPageRewrite(rewrite, ctx) {
+  const reservedPrefixes = getRewriteReservedPrefixes(rewrite);
+  if (!ctx.page.host || isReservedPath(ctx.page.pathname, reservedPrefixes)) {
+    return { notFound: true };
+  }
+  for (const rule of rewrite) {
+    if (!matchesRewriteHost(ctx.page.host, rule.host)) continue;
+    const params = matchRewriteSource(rule.source, ctx.page.pathname);
+    if (!params) continue;
+    const pathname = interpolateRewriteDestination(rule.destination, ctx.page.host, params);
+    if (isReservedPath(pathname, reservedPrefixes)) return { pathname };
+    throw new TypeError('Page rewrite must target its configured internal prefix');
+  }
+  return { pathname: ctx.page.pathname };
+}
+
 async function runPageLoader(route, params, outDir, componentCache, cacheVersion, ctx) {
   const bundlePath = path.join(outDir, route.serverBundle);
   const pageModule = await loadPageModule(
@@ -619,16 +703,24 @@ function assertJsonSerializable(value, label, seen = new Set()) {
   }
   seen.delete(value);
 }
-function buildClientManifestJson(manifest, { rootDir, viteDev, reservedPrefix } = {}) {
-  const clientVisibleManifest = reservedPrefix
-    ? {
-        ...manifest,
-        entries: manifest.entries.filter(
-          (entry) =>
-            entry.pattern !== reservedPrefix && !entry.pattern.startsWith(`${reservedPrefix}/`),
-        ),
-      }
-    : manifest;
+function buildClientManifestJson(
+  manifest,
+  {
+    rootDir,
+    viteDev,
+    reservedPrefix,
+    reservedPrefixes = reservedPrefix ? [reservedPrefix] : [],
+  } = {},
+) {
+  const clientVisibleManifest =
+    reservedPrefixes.length > 0
+      ? {
+          ...manifest,
+          entries: manifest.entries.filter(
+            (entry) => !isReservedPath(entry.pattern, reservedPrefixes),
+          ),
+        }
+      : manifest;
   if (viteDev) {
     return buildViteClientManifestJson(clientVisibleManifest, rootDir);
   }