wrangler 0.0.0-e6733a3 → 0.0.0-e88a54e

package/src/parse.ts

@@ -0,0 +1,183 @@
+import * as fs from "node:fs";
+import { resolve } from "node:path";
+import TOML from "@iarna/toml";
+import { formatMessagesSync } from "esbuild";
+
+export type Message = {
+  text: string;
+  location?: Location;
+  notes?: Message[];
+  kind?: "warning" | "error";
+};
+
+export type Location = File & {
+  line: number;
+  column: number;
+  length?: number;
+  lineText?: string;
+  suggestion?: string;
+};
+
+export type File = {
+  file?: string;
+  fileText?: string;
+};
+
+/**
+ * Formats a `Message` using esbuild's pretty-printing algorithm.
+ */
+export function formatMessage(
+  { text, notes, location, kind = "error" }: Message,
+  color = true
+): string {
+  const input = { text, notes, location };
+  delete input.location?.fileText;
+  for (const note of notes ?? []) {
+    delete note.location?.fileText;
+  }
+  const lines = formatMessagesSync([input], {
+    color,
+    kind: kind,
+    terminalWidth: process.stderr.columns,
+  });
+  return lines.join("\n");
+}
+
+/**
+ * An error that's thrown when something fails to parse.
+ */
+export class ParseError extends Error implements Message {
+  readonly text: string;
+  readonly notes: Message[];
+  readonly location?: Location;
+  readonly kind: "warning" | "error";
+
+  constructor({ text, notes, location, kind }: Message) {
+    super(text);
+    this.name = this.constructor.name;
+    this.text = text;
+    this.notes = notes ?? [];
+    this.location = location;
+    this.kind = kind ?? "error";
+  }
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+const TOML_ERROR_NAME = "TomlError";
+const TOML_ERROR_SUFFIX = " at row ";
+
+type TomlError = Error & {
+  line: number;
+  col: number;
+};
+
+/**
+ * A wrapper around `TOML.parse` that throws a `ParseError`.
+ */
+export function parseTOML(input: string, file?: string): object {
+  try {
+    return TOML.parse(input);
+  } catch (err) {
+    const { name, message, line, col } = err as TomlError;
+    if (name !== TOML_ERROR_NAME) {
+      throw err;
+    }
+    const text = message.substring(0, message.lastIndexOf(TOML_ERROR_SUFFIX));
+    const lineText = input.split("\n")[line];
+    const location = {
+      lineText,
+      line: line + 1,
+      column: col - 1,
+      file,
+      fileText: input,
+    };
+    throw new ParseError({ text, location });
+  }
+}
+
+const JSON_ERROR_SUFFIX = " in JSON at position ";
+
+/**
+ * A wrapper around `JSON.parse` that throws a `ParseError`.
+ */
+export function parseJSON(input: string, file?: string): any {
+  try {
+    return JSON.parse(input);
+  } catch (err) {
+    const { message } = err as Error;
+    const index = message.lastIndexOf(JSON_ERROR_SUFFIX);
+    if (index < 0) {
+      throw err;
+    }
+    const text = message.substring(0, index);
+    const position = parseInt(
+      message.substring(index + JSON_ERROR_SUFFIX.length)
+    );
+    const location = indexLocation({ file, fileText: input }, position);
+    throw new ParseError({ text, location });
+  }
+}
+
+/**
+ * Reads a file and parses it based on its type.
+ */
+export function readFileSync(file: string): string {
+  try {
+    return fs.readFileSync(file, { encoding: "utf-8" });
+  } catch (err) {
+    const { message } = err as Error;
+    throw new ParseError({
+      text: `Could not read file: ${file}`,
+      notes: [
+        {
+          text: message.replace(file, resolve(file)),
+        },
+      ],
+    });
+  }
+}
+
+/**
+ * Calculates the line and column location from an index.
+ */
+export function indexLocation(file: File, index: number): Location {
+  let lineText,
+    line = 0,
+    column = 0,
+    cursor = 0;
+  const { fileText = "" } = file;
+  for (const row of fileText.split("\n")) {
+    line++;
+    cursor += row.length + 1;
+    if (cursor >= index) {
+      lineText = row;
+      column = row.length - (cursor - index);
+      break;
+    }
+  }
+  return { lineText, line, column, ...file };
+}
+
+/**
+ * Guesses the line and column location of a search query.
+ */
+export function searchLocation(file: File, query: unknown): Location {
+  let lineText,
+    length,
+    line = 0,
+    column = 0;
+  const queryText = String(query);
+  const { fileText = "" } = file;
+  for (const content of fileText.split("\n")) {
+    line++;
+    const index = content.indexOf(queryText);
+    if (index >= 0) {
+      lineText = content;
+      column = index;
+      length = queryText.length;
+      break;
+    }
+  }
+  return { lineText, line, column, length, ...file };
+}

package/src/paths.ts

@@ -0,0 +1,26 @@
+import { assert } from "console";
+
+type DiscriminatedPath<Discriminator extends string> = string & {
+  _discriminator: Discriminator;
+};
+
+/**
+ * A branded string that expects to be URL compatible.
+ *
+ * Require this type when you want callers to ensure that they have converted file-path strings into URL-safe paths.
+ */
+export type UrlPath = DiscriminatedPath<"UrlPath">;
+
+/**
+ * Convert a file-path string to a URL-path string.
+ *
+ * Use this helper to convert a `string` to a `UrlPath` when it is not clear whether the string needs normalizing.
+ * Replaces all back-slashes with forward-slashes, and throws an error if the path contains a drive letter (e.g. `C:`).
+ */
+export function toUrlPath(path: string): UrlPath {
+  assert(
+    !/^[a-z]:/i.test(path),
+    "Tried to convert a Windows file path with a drive to a URL path."
+  );
+  return path.replace(/\\/g, "/") as UrlPath;
+}

package/src/proxy.ts

@@ -1,17 +1,27 @@
+import { createServer as createHttpServer } from "node:http";
 import { connect } from "node:http2";
-import type { ServerHttp2Stream } from "node:http2";
-import { createServer } from "node:http";
+import { createServer as createHttpsServer } from "node:https";
+import WebSocket from "faye-websocket";
+import { useEffect, useRef, useState } from "react";
+import serveStatic from "serve-static";
+import { getHttpsOptions } from "./https-options";
+import { reportError } from "./reporting";
+import type { CfPreviewToken } from "./create-worker-preview";
 import type {
   IncomingHttpHeaders,
   RequestListener,
   IncomingMessage,
   ServerResponse,
-  Server,
+  Server as HttpServer,
 } from "node:http";
-import WebSocket from "faye-websocket";
-import serveStatic from "serve-static";
-import type { CfPreviewToken } from "./api/preview";
-import { useEffect, useRef } from "react";
+import type { ClientHttp2Session, ServerHttp2Stream } from "node:http2";
+import type { Server as HttpsServer } from "node:https";
+import type ws from "ws";
+
+interface IWebsocket extends ws {
+  // Pipe implements .on("message", ...)
+  pipe<T>(fn: T): IWebsocket;
+}
 
 /**
  * `usePreviewServer` is a React hook that creates a local development
@@ -41,13 +51,17 @@ function addCfPreviewTokenHeader(
 function rewriteRemoteHostToLocalHostInHeaders(
   headers: IncomingHttpHeaders,
   remoteHost: string,
-  localPort: number
+  localPort: number,
+  localProtocol: "https" | "http"
 ) {
   for (const [name, value] of Object.entries(headers)) {
     // Rewrite the remote host to the local host.
     if (typeof value === "string" && value.includes(remoteHost)) {
       headers[name] = value
-        .replaceAll(`https://${remoteHost}`, `http://localhost:${localPort}`)
+        .replaceAll(
+          `https://${remoteHost}`,
+          `${localProtocol}://localhost:${localPort}`
+        )
         .replaceAll(remoteHost, `localhost:${localPort}`);
     }
   }
@@ -56,40 +70,33 @@ function rewriteRemoteHostToLocalHostInHeaders(
 export function usePreviewServer({
   previewToken,
   publicRoot,
-  port,
+  localProtocol,
+  localPort: port,
+  ip,
 }: {
   previewToken: CfPreviewToken | undefined;
   publicRoot: undefined | string;
-  port: number;
+  localProtocol: "https" | "http";
+  localPort: number;
+  ip: string;
 }) {
   /** Creates an HTTP/1 proxy that sends requests over HTTP/2. */
-  const proxyServer = useRef<Server>();
-  if (!proxyServer.current) {
-    proxyServer.current = createServer()
-      .on("request", function (req, res) {
-        // log all requests
-        console.log(
-          new Date().toLocaleTimeString(),
-          req.method,
-          req.url,
-          res.statusCode
-        );
-      })
-      .on("upgrade", (req) => {
-        // log all websocket connections
-        console.log(
-          new Date().toLocaleTimeString(),
-          req.method,
-          req.url,
-          101,
-          "(WebSocket)"
-        );
-      })
-      .on("error", (err) => {
-        // log all connection errors
-        console.error(new Date().toLocaleTimeString(), err);
-      });
-  }
+  const [proxyServer, setProxyServer] = useState<HttpServer | HttpsServer>();
+
+  /**
+   * Create the instance of the local proxy server that will pass on
+   * requests to the preview worker.
+   */
+  useEffect(() => {
+    if (proxyServer === undefined) {
+      createProxyServer(localProtocol)
+        .then((proxy) => setProxyServer(proxy))
+        .catch(async (err) => {
+          console.error("Failed to create proxy server.", err);
+          await reportError(err);
+        });
+    }
+  }, [proxyServer, localProtocol]);
 
   /**
    * When we're not connected / getting a fresh token on changes,
@@ -105,8 +112,21 @@ export function usePreviewServer({
     { request: IncomingMessage; response: ServerResponse }[]
   >([]);
 
+  /**
+   * The session doesn't last forever, and will eventually drop
+   * (usually within 5-15 minutes). When that happens, we simply
+   * restart the effect, effectively restarting the server. We use
+   * a state sigil as an effect dependency to do so.
+   */
+  const [retryServerSetupSigil, setRetryServerSetupSigil] = useState<number>(0);
+  function retryServerSetup() {
+    setRetryServerSetupSigil((x) => x + 1);
+  }
+
   useEffect(() => {
-    const proxy = proxyServer.current;
+    if (proxyServer === undefined) {
+      return;
+    }
 
     // If we don't have a token, that means either we're just starting up,
     // or we're refreshing the token.
@@ -119,8 +139,8 @@ export function usePreviewServer({
         // store the stream in a buffer so we can replay it later
         streamBufferRef.current.push({ stream, headers });
       };
-      proxy.on("stream", bufferStream);
-      cleanupListeners.push(() => proxy.off("stream", bufferStream));
+      proxyServer.on("stream", bufferStream);
+      cleanupListeners.push(() => proxyServer.off("stream", bufferStream));
 
       const bufferRequestResponse = (
         request: IncomingMessage,
@@ -130,8 +150,10 @@ export function usePreviewServer({
         requestResponseBufferRef.current.push({ request, response });
       };
 
-      proxy.on("request", bufferRequestResponse);
-      cleanupListeners.push(() => proxy.off("request", bufferRequestResponse));
+      proxyServer.on("request", bufferRequestResponse);
+      cleanupListeners.push(() =>
+        proxyServer.off("request", bufferRequestResponse)
+      );
       return () => {
         cleanupListeners.forEach((cleanup) => cleanup());
       };
@@ -146,26 +168,20 @@ export function usePreviewServer({
     const remote = connect(`https://${previewToken.host}`);
     cleanupListeners.push(() => remote.destroy());
 
+    // As mentioned above, the session may die at any point,
+    // so we need to restart the effect.
+    remote.on("close", retryServerSetup);
+    cleanupListeners.push(() => remote.off("close", retryServerSetup));
+
     /** HTTP/2 -> HTTP/2  */
-    function handleStream(
-      stream: ServerHttp2Stream,
-      headers: IncomingHttpHeaders
-    ) {
-      addCfPreviewTokenHeader(headers, previewToken.value);
-      headers[":authority"] = previewToken.host;
-      const request = stream.pipe(remote.request(headers));
-      request.on("response", (responseHeaders: IncomingHttpHeaders) => {
-        rewriteRemoteHostToLocalHostInHeaders(
-          responseHeaders,
-          previewToken.host,
-          port
-        );
-        stream.respond(responseHeaders);
-        request.pipe(stream, { end: true });
-      });
-    }
-    proxy.on("stream", handleStream);
-    cleanupListeners.push(() => proxy.off("stream", handleStream));
+    const handleStream = createStreamHandler(
+      previewToken,
+      remote,
+      port,
+      localProtocol
+    );
+    proxyServer.on("stream", handleStream);
+    cleanupListeners.push(() => proxyServer.off("stream", handleStream));
 
     // flush and replay buffered streams
     streamBufferRef.current.forEach((buffer) =>
@@ -194,11 +210,12 @@ export function usePreviewServer({
       }
       const request = message.pipe(remote.request(headers));
       request.on("response", (responseHeaders) => {
-        const status = responseHeaders[":status"];
+        const status = responseHeaders[":status"] ?? 500;
         rewriteRemoteHostToLocalHostInHeaders(
           responseHeaders,
           previewToken.host,
-          port
+          port,
+          localProtocol
         );
         for (const name of Object.keys(responseHeaders)) {
           if (name.startsWith(":")) {
@@ -216,8 +233,10 @@ export function usePreviewServer({
       ? createHandleAssetsRequest(assetPath, handleRequest)
       : handleRequest;
 
-    proxy.on("request", actualHandleRequest);
-    cleanupListeners.push(() => proxy.off("request", actualHandleRequest));
+    proxyServer.on("request", actualHandleRequest);
+    cleanupListeners.push(() =>
+      proxyServer.off("request", actualHandleRequest)
+    );
 
     // flush and replay buffered requests
     requestResponseBufferRef.current.forEach(({ request, response }) =>
@@ -234,38 +253,59 @@ export function usePreviewServer({
       const { headers, url } = message;
       addCfPreviewTokenHeader(headers, previewToken.value);
       headers["host"] = previewToken.host;
-      const localWebsocket = new WebSocket(message, socket, body);
+      const localWebsocket = new WebSocket(message, socket, body) as IWebsocket;
       // TODO(soon): Custom WebSocket protocol is not working?
       const remoteWebsocketClient = new WebSocket.Client(
         `wss://${previewToken.host}${url}`,
         [],
         { headers }
-      );
+      ) as IWebsocket;
       localWebsocket.pipe(remoteWebsocketClient).pipe(localWebsocket);
       // We close down websockets whenever we refresh the token.
       cleanupListeners.push(() => {
-        localWebsocket.destroy();
-        remoteWebsocketClient.destroy();
+        localWebsocket.close();
+        remoteWebsocketClient.close();
       });
     };
-    proxy.on("upgrade", handleUpgrade);
-    cleanupListeners.push(() => proxy.off("upgrade", handleUpgrade));
+    proxyServer.on("upgrade", handleUpgrade);
+    cleanupListeners.push(() => proxyServer.off("upgrade", handleUpgrade));
 
     return () => {
-      cleanupListeners.forEach((d) => d());
+      cleanupListeners.forEach((cleanup) => cleanup());
     };
-  }, [previewToken, publicRoot, port]);
+  }, [
+    previewToken,
+    publicRoot,
+    port,
+    localProtocol,
+    proxyServer,
+    // We use a state value as a sigil to trigger reconnecting the server.
+    // It's not used inside the effect, so react-hooks/exhaustive-deps
+    // doesn't complain if it's not included in the dependency array.
+    // But its presence is critical, so Do NOT remove it from the dependency list.
+    retryServerSetupSigil,
+  ]);
 
   // Start/stop the server whenever the
   // containing component is mounted/unmounted.
   useEffect(() => {
-    proxyServer.current.listen(port);
-    console.log(`⬣ Listening at http://localhost:${port}`);
+    if (proxyServer === undefined) {
+      return;
+    }
+
+    waitForPortToBeAvailable(port, { retryPeriod: 200, timeout: 2000 })
+      .then(() => {
+        proxyServer.listen(port, ip);
+        console.log(`⬣ Listening at ${localProtocol}://${ip}:${port}`);
+      })
+      .catch((err) => {
+        console.error(`⬣ Failed to start server: ${err}`);
+      });
 
     return () => {
-      proxyServer.current.close();
+      proxyServer.close();
     };
-  }, [port]);
+  }, [port, ip, proxyServer, localProtocol]);
 }
 
 function createHandleAssetsRequest(
@@ -292,3 +332,109 @@ const HTTP1_HEADERS = new Set([
   "transfer-encoding",
   "http2-settings",
 ]);
+
+async function createProxyServer(
+  localProtocol: "https" | "http"
+): Promise<HttpServer | HttpsServer> {
+  const server: HttpServer | HttpsServer =
+    localProtocol === "https"
+      ? createHttpsServer(await getHttpsOptions())
+      : createHttpServer();
+
+  return server
+    .on("request", function (req, res) {
+      // log all requests
+      console.log(
+        new Date().toLocaleTimeString(),
+        req.method,
+        req.url,
+        res.statusCode
+      );
+    })
+    .on("upgrade", (req) => {
+      // log all websocket connections
+      console.log(
+        new Date().toLocaleTimeString(),
+        req.method,
+        req.url,
+        101,
+        "(WebSocket)"
+      );
+    })
+    .on("error", (err) => {
+      // log all connection errors
+      console.error(new Date().toLocaleTimeString(), err);
+    });
+}
+
+function createStreamHandler(
+  previewToken: CfPreviewToken,
+  remote: ClientHttp2Session,
+  localPort: number,
+  localProtocol: "https" | "http"
+) {
+  return function handleStream(
+    stream: ServerHttp2Stream,
+    headers: IncomingHttpHeaders
+  ) {
+    addCfPreviewTokenHeader(headers, previewToken.value);
+    headers[":authority"] = previewToken.host;
+    const request = stream.pipe(remote.request(headers));
+    request.on("response", (responseHeaders: IncomingHttpHeaders) => {
+      rewriteRemoteHostToLocalHostInHeaders(
+        responseHeaders,
+        previewToken.host,
+        localPort,
+        localProtocol
+      );
+      stream.respond(responseHeaders);
+      request.pipe(stream, { end: true });
+    });
+  };
+}
+
+/**
+ * A helper function that waits for a port to be available.
+ */
+export async function waitForPortToBeAvailable(
+  port: number,
+  options: { retryPeriod: number; timeout: number }
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      doReject(new Error(`Timed out waiting for port ${port}`));
+    }, options.timeout);
+
+    const interval = setInterval(checkPort, options.retryPeriod);
+    checkPort();
+
+    function doResolve() {
+      clearTimeout(timeout);
+      clearInterval(interval);
+      resolve();
+    }
+
+    function doReject(err: unknown) {
+      clearInterval(interval);
+      clearTimeout(timeout);
+      reject(err);
+    }
+
+    function checkPort() {
+      // Testing whether a port is 'available' involves simply
+      // trying to make a server listen on that port, and retrying
+      // until it succeeds.
+      const server = createHttpServer();
+      server.on("error", (err) => {
+        // @ts-expect-error non standard property on Error
+        if (err.code !== "EADDRINUSE") {
+          doReject(err);
+        }
+      });
+      server.listen(port, () => {
+        server.close();
+        doResolve();
+      });
+    }
+  });
+}