Function proxyHttpRequest

packages/server/src/routes/previews.ts:335–409

(
  request: FastifyRequest,
  response: ServerResponse,
  workspaceId: string,
  target: NormalizedPreviewTarget,
  previewToken?: string | null,
)

  const targetOrigin = ${JSON.stringify(target.origin)};
  const targetBasePath = ${JSON.stringify(target.basePath)};
  const loopbackHosts = new Set(['localhost', '127.0.0.1', '::1', '[::1]', '0.0.0.0']);
  const normalizeProtocol = (protocol) => protocol === 'ws:' ? 'http:' : protocol === 'wss:' ? 'https:' : protocol;
  const normalizeHost = (hostname) => loopbackHosts.has(hostname.toLowerCase()) ? 'loopback' : hostname.toLowerCase();
  const effectivePort = (url) => url.port || (normalizeProtocol(url.protocol) === 'https:' ? '443' : '80');
  const sameEndpoint = (left, right) => normalizeProtocol(left.protocol) === normalizeProtocol(right.protocol)
    && normalizeHost(left.hostname) === normalizeHost(right.hostname)
    && effectivePort(left) === effectivePort(right);
  const isPrefixed = (pathname) => pathname === prefix || pathname.startsWith(prefix + '/');
  const rewrite = (value) => {
    if (value === undefined || value === null) return value;
    const raw = value instanceof URL ? value.toString() : String(value);
    let url;
    try {
      url = new URL(raw, window.location.href);
    } catch {
      return value;
    }
    if (isPrefixed(url.pathname)) return raw;

    const browserUrl = new URL(window.location.href);
    const localTarget = new URL(targetOrigin);
    const isRootRelative = raw.startsWith('/') && !raw.startsWith('//');
    const isBrowserEndpoint = sameEndpoint(url, browserUrl);
    const isTargetEndpoint = sameEndpoint(url, localTarget);
    if (!isRootRelative && !isTargetEndpoint) return value;
    if (isBrowserEndpoint && !isRootRelative) return value;

    let pathname = url.pathname;
    if (isTargetEndpoint && targetBasePath) {
      const underBasePath = pathname === targetBasePath || pathname.startsWith(targetBasePath + '/');
      if (underBasePath) pathname = pathname.slice(targetBasePath.length) || '/';
    }
    const protocol = url.protocol === 'ws:' || url.protocol === 'wss:'
      ? (window.location.protocol === 'https:' ? 'wss:' : 'ws:')
      : window.location.protocol;
    return protocol + '//' + window.location.host + prefix + pathname + url.search + url.hash;
  };

  const nativePushState = History.prototype.pushState;
  const nativeReplaceState = History.prototype.replaceState;
  History.prototype.pushState = function(state, unused, url) {
    return nativePushState.call(this, state, unused, url == null ? url : rewrite(url));
  };
  History.prototype.replaceState = function(state, unused, url) {
    return nativeReplaceState.call(this, state, unused, url == null ? url : rewrite(url));
  };

  const nativeFetch = window.fetch.bind(window);
  window.fetch = (input, init) => {
    if (typeof input === 'string' || input instanceof URL) return nativeFetch(rewrite(input), init);
    if (input instanceof Request) return nativeFetch(new Request(rewrite(input.url), input), init);
    return nativeFetch(input, init);
  };

  const nativeXhrOpen = XMLHttpRequest.prototype.open;
  XMLHttpRequest.prototype.open = function(method, url, ...rest) {
    return nativeXhrOpen.call(this, method, rewrite(url), ...rest);
  };