orionplace-react 0.7.7 → 0.8.0

package/runtime/marketplace.mjs

@@ -1,905 +0,0 @@
-import { chown, mkdir, readFile, readdir, rename, stat, unlink, writeFile } from 'node:fs/promises';
-import { dirname, relative, resolve } from 'node:path';
-import {
-  getDefaultAutoSelectFamilyAttemptTimeout,
-  isIP,
-  setDefaultAutoSelectFamilyAttemptTimeout,
-} from 'node:net';
-
-const environment     = process.env;
-
-// Node gives each resolved backend address 250 ms to connect before it moves
-// on. Over slower links (VPNs, distant regions) every attempt can expire, and
-// the request fails although the backend is reachable. Allow more time per
-// address; a longer value already chosen by the application is kept.
-const connectTimeout  = 2_000;
-if (getDefaultAutoSelectFamilyAttemptTimeout() < connectTimeout) {
-  setDefaultAutoSelectFamilyAttemptTimeout(connectTimeout);
-}
-
-// A backend answer may take up to 30 seconds. A file upload (multipart form:
-// review photos, cart option files, ticket attachments) also has to send the
-// file first; at 3 Mbit/s a 10 MB file alone takes about 30 seconds, so
-// uploads get 5 minutes.
-const requestTimeout  = 30_000;
-const uploadTimeout   = 300_000;
-
-/** @param {Request} request */
-export function marketplaceRequestTimeout(request) {
-  const contentType = request.headers.get('content-type') ?? '';
-
-  return contentType.toLowerCase().startsWith('multipart/form-data')
-    ? uploadTimeout
-    : requestTimeout;
-}
-
-const hostnamePattern =
-  /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
-
-// Blog media is served outside /api by the backend's guarded /ps3 routes.
-// Only these read-only paths are forwarded; other /ps3 files stay private.
-const blogMediaPattern =
-  /^\/ps3\/blog\/posts\/(?:images\/\d+|videos\/\d+(?:\/preview)?)$/;
-
-/**
- * API answers are never stored. A media file keeps the backend's own browser
- * cache rule when the backend allows it (a published public blog image:
- * "private, max-age=…"); "private" keeps it out of shared caches.
- */
-export function marketplaceCacheControl(media, upstream) {
-  const value = upstream.headers.get('cache-control') ?? '';
-  return media && upstream.ok && /\bprivate\b/i.test(value) && /\bmax-age=\d+/i.test(value) && !/no-store|no-cache/i.test(value)
-    ? value
-    : 'no-store';
-}
-
-/** @param {string} pathname */
-export function isMarketplaceMediaPath(pathname) {
-  return blogMediaPattern.test(pathname);
-}
-
-/** @param {unknown} value */
-export function normalizeFrontDomain(value) {
-  if (typeof value !== 'string') {
-    return null;
-  }
-  const domain = value.split(',')[0].trim().toLowerCase().replace(/\.$/, '');
-  return hostnamePattern.test(domain) && !isIP(domain) ? domain : null;
-}
-
-/** @param {Request} request @param {string} mimic */
-export function resolveFrontDomain(
-  request,
-  mimic = environment.MIMIC_FRONT_DOMAIN || '',
-) {
-  // The hosting proxy must overwrite these headers. Public hosts win over MIMIC.
-  for (const candidate of [
-    request.headers.get('x-front-domain'),
-    request.headers.get('x-forwarded-host'),
-    request.headers.get('host'),
-    new URL(request.url).hostname,
-  ]) {
-    const domain = normalizeFrontDomain(candidate);
-    if (domain) {
-      return domain;
-    }
-  }
-  return normalizeFrontDomain(mimic);
-}
-
-/** @param {Request} request @param {{mimicFrontDomain?: string}} configuration */
-export async function readMarketplace(request, configuration = {}) {
-  const domain    = resolveFrontDomain(request, configuration.mimicFrontDomain);
-  if (!domain) {
-    throw new Error('Invalid storefront domain');
-  }
-  return readMarketplaceDomain(domain);
-}
-
-/**
- * The marketplace of one storefront domain: its `sitemaps/<domain>.cfg` in
- * the project (`root`, the working directory by default).
- * @param {string} name @param {{root?: string}} options
- */
-export async function readMarketplaceDomain(name, options = {}) {
-  const domain    = normalizeFrontDomain(name);
-  if (!domain) {
-    throw new Error('Invalid storefront domain');
-  }
-  const directory = marketplaceConfigDirectory(options.root);
-  const source    = await readFile(resolve(directory, `${domain}.cfg`), 'utf8');
-  const lines     = source
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter((line) => line && !line.startsWith('#'));
-  if (lines.length !== 1) {
-    throw new Error('Expected one API URL');
-  }
-  const value     = lines[0];
-  const api       = new URL(value.includes('://') ? value : `https://${value}`);
-  api.pathname    = api.pathname.replace(/\/+$/, '');
-  if (
-    api.protocol !== 'https:' ||
-    !hostnamePattern.test(api.hostname) ||
-    !api.hostname.endsWith('.orionplace.app') ||
-    isIP(api.hostname) ||
-    api.port ||
-    api.username ||
-    api.password ||
-    api.search ||
-    api.hash ||
-    api.pathname !== '/api'
-  ) {
-    throw new Error('Expected https://<project>.orionplace.app/api');
-  }
-  return { domain, api };
-}
-
-/** The folder of the domain files (`SITEMAPS_DIR`, or `sitemaps`). */
-export function marketplaceConfigDirectory(root = process.cwd()) {
-  return environment.SITEMAPS_DIR
-    ? resolve(root, environment.SITEMAPS_DIR)
-    : resolve(root, 'sitemaps');
-}
-
-// The network can drop a pooled connection to the backend (a reset somewhere
-// between this server and the API host). The request then fails before any
-// answer arrives, so a request that is safe to repeat gets one more try on a
-// new connection instead of a failed page.
-const droppedConnection = new Set([
-  'ECONNRESET',
-  'ECONNABORTED',
-  'EPIPE',
-  'UND_ERR_SOCKET',
-  'UND_ERR_CLOSED',
-]);
-// Application Load only reads, and its body is a small JSON object; a larger
-// body is streamed once without a retry.
-const appLoadPath       = /^\/api\/appload\/?$/;
-const repeatBodyLimit   = 64 * 1024;
-
-/** @param {any} error */
-function connectionDropped(error) {
-  return droppedConnection.has(error?.cause?.code ?? error?.code);
-}
-
-/**
- * The upstream body and whether the request may be sent twice: GET and HEAD
- * have no body; Application Load keeps its small body for a second try.
- * @param {Request} request @param {string} pathname
- * @returns {Promise<{body: any, repeatable: boolean}>}
- */
-async function upstreamBody(request, pathname) {
-  if (['GET', 'HEAD'].includes(request.method)) {
-    return { body: undefined, repeatable: true };
-  }
-  if (!request.body || !appLoadPath.test(pathname)) {
-    return { body: request.body, repeatable: false };
-  }
-  const reader = request.body.getReader();
-  const chunks = [];
-  let size     = 0;
-  for (;;) {
-    const { done, value } = await reader.read();
-    if (done) {
-      return { body: Buffer.concat(chunks), repeatable: true };
-    }
-    chunks.push(value);
-    size += value.byteLength;
-    if (size > repeatBodyLimit) {
-      const body = new ReadableStream({
-        start(controller) {
-          for (const chunk of chunks) {
-            controller.enqueue(chunk);
-          }
-        },
-        async pull(controller) {
-          const next = await reader.read();
-          if (next.done) {
-            controller.close();
-          } else {
-            controller.enqueue(next.value);
-          }
-        },
-        cancel(reason) {
-          return reader.cancel(reason);
-        },
-      });
-      return { body, repeatable: false };
-    }
-  }
-}
-
-/** @param {number} status @param {string} message */
-function failure(status, message) {
-  return Response.json(
-    { error: message },
-    {
-      status,
-      headers: {
-        'Cache-Control': 'no-store',
-        'Vary': 'Host, X-Forwarded-Host, X-Front-Domain',
-      },
-    },
-  );
-}
-
-/** @param {Request} request @param {{mimicFrontDomain?: string}} configuration */
-export async function forwardMarketplace(request, configuration = {}) {
-  let tenant;
-  try {
-    tenant = await readMarketplace(request, configuration);
-  } catch {
-    return failure(
-      503,
-      'Storefront domain configuration is missing or invalid',
-    );
-  }
-
-  const incoming        = new URL(request.url);
-  const media           = isMarketplaceMediaPath(incoming.pathname);
-  if (!incoming.pathname.startsWith('/api/') && !media) {
-    return failure(404, 'Unknown API path');
-  }
-  if (media && !['GET', 'HEAD'].includes(request.method)) {
-    return failure(405, 'Media is read-only');
-  }
-  // Prevent encoded separators or traversal from escaping the /api namespace.
-  let path;
-  try {
-    path = decodeURIComponent(incoming.pathname);
-  } catch {
-    return failure(400, 'Invalid API path');
-  }
-  if (
-    path.includes('\\') ||
-    /%(?:2e|2f|5c)/i.test(path) ||
-    path.split('/').some((part) => part === '.' || part === '..')
-  ) {
-    return failure(400, 'Invalid API path');
-  }
-  const target          = new URL(
-    incoming.pathname + incoming.search,
-    tenant.api.origin,
-  );
-  if (
-    media
-      ? !isMarketplaceMediaPath(target.pathname)
-      : !target.pathname.startsWith('/api/')
-  ) {
-    return failure(400, 'Invalid API path');
-  }
-
-  const origin          = request.headers.get('origin');
-  const publicHost      = request.headers.get('host') || incoming.host;
-  const originHosts     = [publicHost, tenant.domain];
-  if (!['GET', 'HEAD', 'OPTIONS'].includes(request.method)) {
-    try {
-      if (
-        request.headers.get('sec-fetch-site') === 'cross-site' ||
-        (origin && !originHosts.includes(new URL(origin).host))
-      ) {
-        return failure(403, 'Cross-site API request rejected');
-      }
-    } catch {
-      return failure(403, 'Invalid Origin');
-    }
-  }
-
-  // An allowlist excludes hop-by-hop and client-supplied routing headers.
-  const headers         = new Headers();
-  for (const name of [
-    'accept',
-    'content-type',
-    'authorization',
-    'cookie',
-    'origin',
-    'referer',
-    'x-csrftoken',
-    'accept-language',
-    'user-agent',
-    'x-tz',
-    'range',
-  ]) {
-    const value = request.headers.get(name);
-    if (value) {
-      headers.set(name, value);
-    }
-  }
-  headers.set('X-Front-Domain', tenant.domain);
-  // The backend accepts forms from the storefront domain's own origin. A public
-  // host that shows this storefront (MIMIC, a preview host or a local port)
-  // passed the same-origin check above, so it is sent as that origin.
-  let ownOrigin         = false;
-  try {
-    ownOrigin = Boolean(origin) && originHosts.includes(new URL(origin).host);
-  } catch {
-    ownOrigin = false;
-  }
-  if (ownOrigin) {
-    headers.set('origin', `https://${tenant.domain}`);
-  }
-  headers.set('Accept-Encoding', 'identity');
-  const clientIp        =
-    request.headers.get('x-init-ip') ||
-    request.headers.get('x-real-ip') ||
-    request.headers.get('x-forwarded-for')?.split(',')[0]?.trim();
-  if (clientIp) {
-    headers.set('X-Init-Ip', clientIp);
-  }
-  /** @type {RequestInit & { duplex: 'half' }} */
-  const options         = {
-    method: request.method,
-    headers,
-    redirect: 'manual',
-    cache: 'no-store',
-    signal: AbortSignal.any([
-      request.signal,
-      AbortSignal.timeout(marketplaceRequestTimeout(request)),
-    ]),
-    duplex: 'half',
-  };
-  let upstream;
-  try {
-    const { body, repeatable } = await upstreamBody(request, incoming.pathname);
-    if (body !== undefined) {
-      options.body = body;
-    }
-    try {
-      upstream = await fetch(target, options);
-    } catch (error) {
-      if (!repeatable || !connectionDropped(error) || options.signal.aborted) {
-        throw error;
-      }
-      console.warn(
-        `[orionplace] Backend connection dropped (${error?.cause?.code ?? error?.code}), retrying once`,
-      );
-      upstream = await fetch(target, options);
-    }
-  } catch (error) {
-    // The browser receives only the status; keep the cause in the server log.
-    if (!request.signal.aborted) {
-      const cause = error?.cause?.code ?? error?.message ?? String(error);
-      console.error(`[orionplace] Backend request failed: ${cause}`);
-    }
-    return failure(502, 'Marketplace backend is unavailable');
-  }
-
-  const responseHeaders = new Headers();
-  for (const name of [
-    'content-type',
-    'content-disposition',
-    'www-authenticate',
-    'retry-after',
-    'allow',
-    'accept-ranges',
-    'content-range',
-  ]) {
-    const value = upstream.headers.get(name);
-    if (value) {
-      responseHeaders.set(name, value);
-    }
-  }
-  // Keep each cookie separate; remove the backend Domain attribute only.
-  for (const cookie of upstream.headers.getSetCookie()) {
-    responseHeaders.append(
-      'Set-Cookie',
-      cookie.replace(/;\s*Domain=[^;]*/gi, ''),
-    );
-  }
-  const location        = upstream.headers.get('location');
-  if (location) {
-    const destination = new URL(location, target);
-    responseHeaders.set(
-      'Location',
-      destination.origin === tenant.api.origin
-        ? destination.pathname + destination.search + destination.hash
-        : destination.href,
-    );
-  }
-  responseHeaders.set('Cache-Control', marketplaceCacheControl(media, upstream));
-  responseHeaders.set('Vary', 'Host, X-Forwarded-Host, X-Front-Domain');
-  // fetch decodes compressed bodies: do not reuse upstream Content-Length/Encoding.
-  return new Response(upstream.body, {
-    status: upstream.status,
-    statusText: upstream.statusText,
-    headers: responseHeaders,
-  });
-}
-
-// ---------------------------------------------------------------------------
-// robots.txt and sitemap.xml
-//
-// The sitemap lists the storefront's public pages in every language the
-// marketplace offers (`?locale=<code>` links, with hreflang alternates): the
-// home, catalog and directory pages, the journal and its publications when
-// the blog is on, the subscription plans when there are any, every public
-// category and every product on sale. It is built from the backend's public
-// API and kept for an hour per storefront domain in
-// node_modules/.cache/orionplace/sitemaps/<domain>.json (ORIONPLACE_CACHE_DIR
-// moves it). "orionplace-<framework> sitemap rebuild" rebuilds that file at
-// once; the running storefront serves the new file without a restart.
-// Paths in ORIONPLACE_NOINDEX_PATHS are left out when the sitemap is served.
-
-export const SITEMAP_LIFETIME = 60 * 60 * 1000;
-const sitemapPageSize = 100;
-const sitemapMaxPages = 500;
-const sitemapMaxUrls  = 50_000;
-const sitemapVersion  = 1;
-/** Built sitemaps of this process, for when the cache folder is read-only. */
-const sitemapMemory   = new Map();
-/** @type {Map<string, Promise<object>>} */
-const sitemapBuilds   = new Map();
-
-/** The public origin a crawler used: the storefront host, or a local one. */
-export function marketplacePublicOrigin(request, tenantDomain = '') {
-  const url  = new URL(request.url);
-  const host = normalizeFrontDomain(
-    request.headers.get('x-forwarded-host') ?? request.headers.get('host') ?? '',
-  );
-  if (host) {
-    return `https://${host}`;
-  }
-  const local = /^(?:localhost|127(?:\.\d{1,3}){3}|\[::1\])$/.test(url.hostname);
-  return local || !tenantDomain ? url.origin : `https://${tenantDomain}`;
-}
-
-/**
- * Pages kept out of search engines: ORIONPLACE_NOINDEX_PATHS lists path
- * prefixes separated by spaces or commas, for example "/catalog /category
- * /product" on a demo or staging storefront. Those pages answer with
- * `X-Robots-Tag: noindex, follow` and the sitemap leaves them out. Empty
- * (the default) keeps every public page indexable.
- */
-export function noindexPathPrefixes(value = environment.ORIONPLACE_NOINDEX_PATHS) {
-  return String(value ?? '')
-    .split(/[\s,]+/)
-    .map((item) => item.trim().replace(/\/+$/, ''))
-    .filter((item) => /^\/[A-Za-z0-9._~\/-]+$/.test(item));
-}
-
-/** Whether a page path is kept out of search engines (see noindexPathPrefixes). */
-export function marketplaceNoindexPath(pathname, value = environment.ORIONPLACE_NOINDEX_PATHS) {
-  const path = String(pathname ?? '');
-  return noindexPathPrefixes(value)
-    .some((prefix) => path === prefix || path.startsWith(`${prefix}/`));
-}
-
-/** The sitemap pages search engines may index. */
-export function sitemapIndexedPages(pages, value = environment.ORIONPLACE_NOINDEX_PATHS) {
-  return noindexPathPrefixes(value).length
-    ? pages.filter((page) => !marketplaceNoindexPath(page.path, value))
-    : pages;
-}
-
-/** @param {string} origin */
-export function marketplaceRobots(origin) {
-  return `User-agent: *\nDisallow: /api/\nAllow: /\n\nSitemap: ${origin}/sitemap.xml\n`;
-}
-
-/** @param {Request} request @param {{mimicFrontDomain?: string}} configuration */
-export async function marketplaceRobotsResponse(request, configuration = {}) {
-  let domain = '';
-  try {
-    domain = (await readMarketplace(request, configuration)).domain;
-  } catch {
-    domain = '';
-  }
-  return new Response(
-    marketplaceRobots(marketplacePublicOrigin(request, domain)),
-    {
-      headers: {
-        'Content-Type': 'text/plain; charset=utf-8',
-        'Cache-Control': 'public, max-age=3600',
-        'Vary': 'Host, X-Forwarded-Host, X-Front-Domain',
-      },
-    },
-  );
-}
-
-/** @param {string} value */
-function escapeXml(value) {
-  return value.replace(/[<>&"']/g, (character) => ({
-    '<': '&lt;', '>': '&gt;', '&': '&amp;', '"': '&quot;', "'": '&apos;',
-  })[character]);
-}
-
-/** @param {unknown} value */
-function publicId(value) {
-  const id = Number(value);
-  return Number.isSafeInteger(id) && id > 0 ? id : null;
-}
-
-/** The marketplace's languages from /appload `init.locale`. */
-export function sitemapLocales(locales) {
-  const codes = Object.entries(locales && typeof locales === 'object' ? locales : {})
-    .map(([key, item]) => String(item?.code || key).trim().toLowerCase())
-    .filter((code) => /^[a-z]{2,3}(?:-[a-z0-9]{2,8})*$/.test(code));
-  return [...new Set(codes)].sort();
-}
-
-/** A product edit time (ISO 8601) or a blog post day ({date: 'DD.MM.YYYY'}). */
-export function sitemapLastmod(value, now = Date.now()) {
-  if (typeof value === 'string' && value) {
-    const time = Date.parse(value);
-    return Number.isFinite(time) && time <= now + 60_000
-      ? new Date(time).toISOString().replace(/\.\d{3}Z$/, 'Z')
-      : null;
-  }
-  const match = /^(\d{2})\.(\d{2})\.(\d{4})$/.exec(value?.date ?? '');
-  if (!match) {
-    return null;
-  }
-  const [, day, month, year] = match;
-  const time  = Date.UTC(Number(year), Number(month) - 1, Number(day));
-  const date  = new Date(time);
-  return date.getUTCDate() === Number(day) &&
-    date.getUTCMonth() === Number(month) - 1 &&
-    time <= now + 24 * 60 * 60 * 1000
-    ? `${year}-${month}-${day}`
-    : null;
-}
-
-/** The API path (under /api) of a route named in /appload `unauth.paths`. */
-export function sitemapApiPath(paths, name) {
-  for (const group of Object.values(paths ?? {})) {
-    for (const route of Object.values(group ?? {})) {
-      if (route?.url_name === name) {
-        const target = String(route.target ?? '').split('/{')[0].replace(/^\/+/, '');
-        return target.startsWith('api/') ? `/${target}` : null;
-      }
-    }
-  }
-  return null;
-}
-
-/** Public categories, parents before children. */
-export function sitemapCategoryIds(categories) {
-  const ids   = [];
-  const visit = (category) => {
-    const id = publicId(category?.id);
-    if (id && category?.is_public) {
-      ids.push(id);
-    }
-    (category?.childs ?? []).forEach(visit);
-  };
-  (Array.isArray(categories) ? categories : []).forEach(visit);
-  return [...new Set(ids)];
-}
-
-/**
- * One <url> per page and language, each with alternates for its languages.
- * A page with its own `locales` (a publication written in some languages
- * only) is listed in those of the marketplace's languages.
- * @param {string} origin
- * @param {{path: string, lastmod?: string | null, locales?: string[]}[]} pages
- * @param {string[]} locales
- */
-export function marketplaceSitemapXml(origin, pages, locales) {
-  const href  = (path, code) => {
-    const url = new URL(path, `${origin}/`);
-    if (code) {
-      url.searchParams.set('locale', code);
-    }
-    return escapeXml(url.toString());
-  };
-  const urls  = [];
-  for (const page of pages) {
-    const own        = page.locales
-      ? locales.filter((code) => page.locales.includes(code))
-      : locales;
-    if (page.locales && !own.length) {
-      continue;
-    }
-    const codes      = own.length ? own : [''];
-    const alternates = own.length > 1
-      ? own.map((code) =>
-        `    <xhtml:link rel="alternate" hreflang="${escapeXml(code)}" href="${href(page.path, code)}" />\n`).join('')
-      : '';
-    const lastmod    = page.lastmod ? `    <lastmod>${escapeXml(page.lastmod)}</lastmod>\n` : '';
-    for (const code of codes) {
-      if (urls.length >= sitemapMaxUrls) {
-        break;
-      }
-      urls.push(`  <url>\n    <loc>${href(page.path, code)}</loc>\n${lastmod}${alternates}  </url>\n`);
-    }
-  }
-  return '<?xml version="1.0" encoding="UTF-8"?>\n' +
-    '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">\n' +
-    urls.join('') +
-    '</urlset>\n';
-}
-
-/** @param {{domain: string, api: URL}} tenant @param {string} path @param {unknown} body */
-async function sitemapRequest(tenant, path, body) {
-  const response = await fetch(new URL(path, tenant.api.origin), {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'Accept': 'application/json',
-      'X-Front-Domain': tenant.domain,
-    },
-    body: JSON.stringify(body),
-    cache: 'no-store',
-    signal: AbortSignal.timeout(requestTimeout),
-  });
-  if (!response.ok) {
-    throw new Error(`${path} answered ${response.status}`);
-  }
-  return response.json();
-}
-
-/** Every record of a paginated list (`page_data[key].data` + `rpag`). */
-async function sitemapList(tenant, path, key, filters = {}) {
-  const records = new Map();
-  let page      = 1;
-  for (let count = 0; count < sitemapMaxPages; count++) {
-    const payload = await sitemapRequest(tenant, path, {
-      filters,
-      paginate: { page, pp_items: sitemapPageSize },
-    });
-    const list    = payload?.page_data?.[key];
-    if (!Array.isArray(list?.data)) {
-      throw new Error(`${path} returned no ${key} list`);
-    }
-    for (const record of list.data) {
-      const id = publicId(record?.id);
-      if (id) {
-        records.set(id, record);
-      }
-    }
-    const next    = Number(list.rpag?.next_page_number);
-    if (!list.rpag?.has_next || !Number.isSafeInteger(next) || next <= page) {
-      return [...records.values()];
-    }
-    page          = next;
-  }
-  throw new Error(`${path} has more than ${sitemapMaxPages} pages`);
-}
-
-/** Products on sale and in stock states a shopper can open. */
-function productOnSale(product) {
-  const status = Number(product?.status?.status ?? product?.status);
-  return [2, -2, -3].includes(status);
-}
-
-/** Blog publications that are published. */
-function postPublished(post) {
-  const state = post?.publishing_state?.int ?? post?.publishing_state;
-  return state === undefined || state === null || Number(state) === 1;
-}
-
-/** The languages a publication is written in (it has a title there). */
-function postLocales(post) {
-  return Object.entries(post?.locale && typeof post.locale === 'object' ? post.locale : {})
-    .filter(([, text]) => typeof text?.post_title === 'string' && text.post_title.trim())
-    .map(([code]) => code.toLowerCase());
-}
-
-/** @param {{domain: string, api: URL}} tenant */
-async function buildMarketplaceSitemap(tenant) {
-  const appload    = await sitemapRequest(tenant, '/api/appload', {
-    detalize_mode: 'light',
-    ignore_cache: false,
-  });
-  const init       = appload?.page_data?.init;
-  const paths      = appload?.page_data?.unauth?.paths;
-  if (!init || !Array.isArray(init.catalog)) {
-    throw new Error('appload returned no catalog');
-  }
-  const locales    = sitemapLocales(init.locale);
-  const categories = sitemapCategoryIds(init.catalog);
-  const blogPath   = sitemapApiPath(paths, 'blog_posts_get');
-  const searchPath = sitemapApiPath(paths, 'products_search');
-  const [products, posts] = await Promise.all([
-    searchPath && categories.length
-      ? sitemapList(tenant, searchPath, 'products', { categories })
-      : [],
-    blogPath ? sitemapList(tenant, blogPath, 'posts') : [],
-  ]);
-  const postPages  = posts
-    .filter(postPublished)
-    .sort((left, right) => left.id - right.id)
-    .map((post) => ({
-      path: `/journal/${post.id}`,
-      lastmod: sitemapLastmod(post.date_updated),
-      locales: postLocales(post),
-    }));
-  const newestPost = postPages.map((page) => page.lastmod).filter(Boolean).sort().at(-1) ?? null;
-  const pages      = [
-    { path: '/' },
-    { path: '/catalog' },
-    ...(blogPath ? [{ path: '/journal', lastmod: newestPost }] : []),
-    ...(init.tariffs?.data?.length ? [{ path: '/tariffs' }] : []),
-    { path: '/manufacturers' },
-    ...(init.visual_settings?.single_seller_mode ? [] : [{ path: '/sellers' }]),
-    { path: '/stores' },
-    { path: '/contact' },
-    { path: '/privacy' },
-    ...categories.map((id) => ({ path: `/category/${id}` })),
-    ...products
-      .filter(productOnSale)
-      .map((product) => ({
-        path: `/product/${product.id}`,
-        lastmod: sitemapLastmod(product.date_updated),
-      })),
-    ...postPages,
-  ];
-  return {
-    version: sitemapVersion,
-    domain: tenant.domain,
-    built: new Date().toISOString(),
-    locales,
-    pages,
-  };
-}
-
-/** How many <url> entries a built sitemap has. */
-export function sitemapUrlCount(sitemap) {
-  let count = 0;
-  for (const page of sitemapIndexedPages(sitemap.pages)) {
-    const own = page.locales
-      ? sitemap.locales.filter((code) => page.locales.includes(code))
-      : sitemap.locales;
-    count    += page.locales ? own.length : Math.max(own.length, 1);
-  }
-  return Math.min(count, sitemapMaxUrls);
-}
-
-/** The cache folder of built sitemaps. */
-export function sitemapCacheDirectory(root = process.cwd()) {
-  return environment.ORIONPLACE_CACHE_DIR
-    ? resolve(root, environment.ORIONPLACE_CACHE_DIR, 'sitemaps')
-    : resolve(root, 'node_modules', '.cache', 'orionplace', 'sitemaps');
-}
-
-/** @param {string} domain @param {string} root */
-function sitemapCachePath(domain, root) {
-  return resolve(sitemapCacheDirectory(root), `${domain}.json`);
-}
-
-/** A cached sitemap of the domain, or null. @param {string} domain */
-export async function readSitemapCache(domain, root = process.cwd()) {
-  let sitemap;
-  try {
-    sitemap = JSON.parse(await readFile(sitemapCachePath(domain, root), 'utf8'));
-  } catch {
-    return null;
-  }
-  return sitemap?.version === sitemapVersion &&
-    sitemap.domain === domain &&
-    Number.isFinite(Date.parse(sitemap.built)) &&
-    Array.isArray(sitemap.locales) &&
-    Array.isArray(sitemap.pages)
-    ? sitemap
-    : null;
-}
-
-/**
- * Write the cache file. When root writes it (sudo), the folders it creates
- * and the file go to the project owner, so the storefront service can
- * replace them later.
- */
-async function writeSitemapCache(sitemap, root) {
-  const path      = sitemapCachePath(sitemap.domain, root);
-  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
-  await mkdir(dirname(path), { recursive: true });
-  try {
-    await writeFile(temporary, JSON.stringify(sitemap), { mode: 0o644 });
-    await rename(temporary, path);
-  } catch (error) {
-    await unlink(temporary).catch(() => {});
-    throw error;
-  }
-  if (process.getuid?.() === 0) {
-    const owner = await stat(root);
-    if (owner.uid !== 0) {
-      let cursor = path;
-      while (cursor !== root && !relative(root, cursor).startsWith('..')) {
-        const info = await stat(cursor);
-        if (info.uid === 0) {
-          await chown(cursor, owner.uid, owner.gid);
-        }
-        cursor = dirname(cursor);
-      }
-    }
-  }
-  return path;
-}
-
-/** @param {{domain: string, api: URL}} tenant @param {string} root */
-function buildOnce(tenant, root) {
-  let build = sitemapBuilds.get(tenant.domain);
-  if (!build) {
-    build = buildMarketplaceSitemap(tenant)
-      .then(async (sitemap) => {
-        sitemapMemory.set(tenant.domain, sitemap);
-        try {
-          await writeSitemapCache(sitemap, root);
-        } catch (error) {
-          console.error(`[orionplace] Sitemap cache not written: ${error?.code ?? error?.message ?? error}`);
-        }
-        return sitemap;
-      })
-      .finally(() => sitemapBuilds.delete(tenant.domain));
-    sitemapBuilds.set(tenant.domain, build);
-  }
-  return build;
-}
-
-/**
- * Rebuild the sitemap of one storefront domain now and store it where the
- * running storefront reads it (the "sitemap rebuild" command).
- * @param {string} domain @param {{root?: string}} options
- */
-export async function rebuildMarketplaceSitemap(domain, options = {}) {
-  const root    = resolve(options.root ?? process.cwd());
-  const tenant  = await readMarketplaceDomain(domain, { root });
-  const sitemap = await buildMarketplaceSitemap(tenant);
-  const path    = await writeSitemapCache(sitemap, root);
-  return {
-    domain: tenant.domain,
-    path,
-    built: sitemap.built,
-    urls: sitemapUrlCount(sitemap),
-    pages: sitemap.pages.length,
-    publications: sitemap.pages.filter((page) => page.path.startsWith('/journal/')).length,
-  };
-}
-
-/** The storefront domains of the project (its `sitemaps/*.cfg` files). */
-export async function marketplaceDomains(root = process.cwd()) {
-  let names;
-  try {
-    names = await readdir(marketplaceConfigDirectory(root));
-  } catch (error) {
-    if (error?.code === 'ENOENT') {
-      return [];
-    }
-    throw error;
-  }
-  return names
-    .filter((name) => name.endsWith('.cfg'))
-    .map((name) => normalizeFrontDomain(name.slice(0, -4)))
-    .filter(Boolean)
-    .sort();
-}
-
-/** @param {Request} request @param {{mimicFrontDomain?: string}} configuration */
-export async function marketplaceSitemapResponse(request, configuration = {}) {
-  let tenant;
-  try {
-    tenant = await readMarketplace(request, configuration);
-  } catch {
-    return failure(503, 'Storefront domain configuration is missing or invalid');
-  }
-  const root    = process.cwd();
-  const fresh   = (sitemap) =>
-    sitemap && Date.now() - Date.parse(sitemap.built) < SITEMAP_LIFETIME;
-  // The file wins when it is newer: a "sitemap rebuild" replaced it.
-  const file    = await readSitemapCache(tenant.domain, root);
-  const memory  = sitemapMemory.get(tenant.domain);
-  const newest  = [file, memory]
-    .filter(Boolean)
-    .sort((left, right) => Date.parse(right.built) - Date.parse(left.built))[0];
-  let sitemap   = fresh(newest) ? newest : null;
-  if (!sitemap) {
-    try {
-      sitemap = await buildOnce(tenant, root);
-    } catch (error) {
-      console.error(`[orionplace] Sitemap build failed: ${error?.message ?? error}`);
-      if (!newest) {
-        return failure(502, 'Marketplace backend is unavailable');
-      }
-      sitemap = newest;
-    }
-  }
-  const origin  = marketplacePublicOrigin(request, tenant.domain);
-  return new Response(marketplaceSitemapXml(origin, sitemapIndexedPages(sitemap.pages), sitemap.locales), {
-    headers: {
-      'Content-Type': 'application/xml; charset=utf-8',
-      'Cache-Control': 'public, max-age=3600',
-      'Vary': 'Host, X-Forwarded-Host, X-Front-Domain',
-    },
-  });
-}