wrangler 0.0.0-ece06ea → 0.0.0-edc4b53

package/src/proxy.ts

@@ -0,0 +1,294 @@
+import { connect } from "node:http2";
+import type { ServerHttp2Stream } from "node:http2";
+import { createServer } from "node:http";
+import type {
+  IncomingHttpHeaders,
+  RequestListener,
+  IncomingMessage,
+  ServerResponse,
+  Server,
+} from "node:http";
+import WebSocket from "faye-websocket";
+import serveStatic from "serve-static";
+import type { CfPreviewToken } from "./api/preview";
+import { useEffect, useRef } from "react";
+
+/**
+ * `usePreviewServer` is a React hook that creates a local development
+ * server that can be used to develop a Worker.
+ *
+ * When we run `wrangler dev`, we start by uploading the compiled worker
+ * to the preview service, which responds with a preview token.
+ * (see `useWorker`/`createWorker` for details.)
+ * We can then use that token to connect to the preview server for a
+ * great local development experience. Further, as we change the worker,
+ * we can update the preview token transparently without having to restart
+ * the development server.
+ */
+
+/** Rewrite request headers to add the preview token. */
+function addCfPreviewTokenHeader(
+  headers: IncomingHttpHeaders,
+  previewTokenValue: string
+) {
+  headers["cf-workers-preview-token"] = previewTokenValue;
+}
+
+/**
+ * Rewrite references in request headers
+ * from the preview host to the local host.
+ */
+function rewriteRemoteHostToLocalHostInHeaders(
+  headers: IncomingHttpHeaders,
+  remoteHost: string,
+  localPort: number
+) {
+  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(remoteHost, `localhost:${localPort}`);
+    }
+  }
+}
+
+export function usePreviewServer({
+  previewToken,
+  publicRoot,
+  port,
+}: {
+  previewToken: CfPreviewToken | undefined;
+  publicRoot: undefined | string;
+  port: number;
+}) {
+  /** 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);
+      });
+  }
+
+  /**
+   * When we're not connected / getting a fresh token on changes,
+   * we'd like to buffer streams/requests until we're connected.
+   * Once connected, we can flush the buffered streams/requests.
+   * streamBufferRef is used to buffer http/2 streams, while
+   * requestResponseBufferRef is used to buffer http/1 requests.
+   */
+  const streamBufferRef = useRef<
+    { stream: ServerHttp2Stream; headers: IncomingHttpHeaders }[]
+  >([]);
+  const requestResponseBufferRef = useRef<
+    { request: IncomingMessage; response: ServerResponse }[]
+  >([]);
+
+  useEffect(() => {
+    const proxy = proxyServer.current;
+
+    // If we don't have a token, that means either we're just starting up,
+    // or we're refreshing the token.
+    if (!previewToken) {
+      const cleanupListeners: (() => void)[] = [];
+      const bufferStream = (
+        stream: ServerHttp2Stream,
+        headers: IncomingHttpHeaders
+      ) => {
+        // 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));
+
+      const bufferRequestResponse = (
+        request: IncomingMessage,
+        response: ServerResponse
+      ) => {
+        // store the request and response in a buffer so we can replay it later
+        requestResponseBufferRef.current.push({ request, response });
+      };
+
+      proxy.on("request", bufferRequestResponse);
+      cleanupListeners.push(() => proxy.off("request", bufferRequestResponse));
+      return () => {
+        cleanupListeners.forEach((cleanup) => cleanup());
+      };
+    }
+
+    // We have a token. Let's proxy requests to the preview end point.
+    const cleanupListeners: (() => void)[] = [];
+
+    const assetPath = typeof publicRoot === "string" ? publicRoot : null;
+
+    // create a ClientHttp2Session
+    const remote = connect(`https://${previewToken.host}`);
+    cleanupListeners.push(() => remote.destroy());
+
+    /** 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));
+
+    // flush and replay buffered streams
+    streamBufferRef.current.forEach((buffer) =>
+      handleStream(buffer.stream, buffer.headers)
+    );
+    streamBufferRef.current = [];
+
+    /** HTTP/1 -> HTTP/2  */
+    const handleRequest: RequestListener = (
+      message: IncomingMessage,
+      response: ServerResponse
+    ) => {
+      const { httpVersionMajor, headers, method, url } = message;
+      if (httpVersionMajor >= 2) {
+        return; // Already handled by the "stream" event.
+      }
+      addCfPreviewTokenHeader(headers, previewToken.value);
+      headers[":method"] = method;
+      headers[":path"] = url;
+      headers[":authority"] = previewToken.host;
+      headers[":scheme"] = "https";
+      for (const name of Object.keys(headers)) {
+        if (HTTP1_HEADERS.has(name.toLowerCase())) {
+          delete headers[name];
+        }
+      }
+      const request = message.pipe(remote.request(headers));
+      request.on("response", (responseHeaders) => {
+        const status = responseHeaders[":status"];
+        rewriteRemoteHostToLocalHostInHeaders(
+          responseHeaders,
+          previewToken.host,
+          port
+        );
+        for (const name of Object.keys(responseHeaders)) {
+          if (name.startsWith(":")) {
+            delete responseHeaders[name];
+          }
+        }
+        response.writeHead(status, responseHeaders);
+        request.pipe(response, { end: true });
+      });
+    };
+
+    // If an asset path is defined, check the file system
+    // for a file first and serve if it exists.
+    const actualHandleRequest = assetPath
+      ? createHandleAssetsRequest(assetPath, handleRequest)
+      : handleRequest;
+
+    proxy.on("request", actualHandleRequest);
+    cleanupListeners.push(() => proxy.off("request", actualHandleRequest));
+
+    // flush and replay buffered requests
+    requestResponseBufferRef.current.forEach(({ request, response }) =>
+      actualHandleRequest(request, response)
+    );
+    requestResponseBufferRef.current = [];
+
+    /** HTTP/1 -> WebSocket (over HTTP/1)  */
+    const handleUpgrade = (
+      message: IncomingMessage,
+      socket: WebSocket,
+      body: Buffer
+    ) => {
+      const { headers, url } = message;
+      addCfPreviewTokenHeader(headers, previewToken.value);
+      headers["host"] = previewToken.host;
+      const localWebsocket = new WebSocket(message, socket, body);
+      // TODO(soon): Custom WebSocket protocol is not working?
+      const remoteWebsocketClient = new WebSocket.Client(
+        `wss://${previewToken.host}${url}`,
+        [],
+        { headers }
+      );
+      localWebsocket.pipe(remoteWebsocketClient).pipe(localWebsocket);
+      // We close down websockets whenever we refresh the token.
+      cleanupListeners.push(() => {
+        localWebsocket.destroy();
+        remoteWebsocketClient.destroy();
+      });
+    };
+    proxy.on("upgrade", handleUpgrade);
+    cleanupListeners.push(() => proxy.off("upgrade", handleUpgrade));
+
+    return () => {
+      cleanupListeners.forEach((d) => d());
+    };
+  }, [previewToken, publicRoot, port]);
+
+  // Start/stop the server whenever the
+  // containing component is mounted/unmounted.
+  useEffect(() => {
+    proxyServer.current.listen(port);
+    console.log(`⬣ Listening at http://localhost:${port}`);
+
+    return () => {
+      proxyServer.current.close();
+    };
+  }, [port]);
+}
+
+function createHandleAssetsRequest(
+  assetPath: string,
+  handleRequest: RequestListener
+) {
+  const handleAsset = serveStatic(assetPath, {
+    cacheControl: false,
+  });
+  return (request: IncomingMessage, response: ServerResponse) => {
+    handleAsset(request, response, () => {
+      handleRequest(request, response);
+    });
+  };
+}
+
+/** A Set of headers we want to remove from HTTP/1 requests. */
+const HTTP1_HEADERS = new Set([
+  "host",
+  "connection",
+  "upgrade",
+  "keep-alive",
+  "proxy-connection",
+  "transfer-encoding",
+  "http2-settings",
+]);

package/src/publish.ts

@@ -1,17 +1,17 @@
-import type { CfWorkerInit } from "./api/worker";
-import { toFormData } from "./api/form_data";
+import assert from "node:assert";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
 import esbuild from "esbuild";
+import { execa } from "execa";
 import tmp from "tmp-promise";
+import type { CfWorkerInit } from "./api/worker";
+import { toFormData } from "./api/form_data";
+import { fetchResult } from "./cfetch";
 import type { Config } from "./config";
-import path from "path";
-import { readFile } from "fs/promises";
-import cfetch from "./cfetch";
-import assert from "node:assert";
+import makeModuleCollector from "./module-collection";
 import { syncAssets } from "./sites";
-import NodeModulesPolyfills from "@esbuild-plugins/node-modules-polyfill";
-import NodeGlobalsPolyfills from "@esbuild-plugins/node-globals-polyfill";
 
-type CfScriptFormat = void | "modules" | "service-worker";
+type CfScriptFormat = undefined | "modules" | "service-worker";
 
 type Props = {
   config: Config;
@@ -19,14 +19,15 @@ type Props = {
   script?: string;
   name?: string;
   env?: string;
+  compatibilityDate?: string;
+  compatibilityFlags?: string[];
   public?: string;
   site?: string;
   triggers?: (string | number)[];
   routes?: (string | number)[];
   legacyEnv?: boolean;
-  jsxFactory: void | string;
-  jsxFragment: void | string;
-  polyfillNode: void | boolean;
+  jsxFactory: undefined | string;
+  jsxFragment: undefined | string;
 };
 
 function sleep(ms: number) {
@@ -49,6 +50,13 @@ export default async function publish(props: Props): Promise<void> {
     __path__,
   } = config;
 
+  const envRootObj = props.env ? config.env[props.env] || {} : config;
+
+  assert(
+    envRootObj.compatibility_date || props["compatibility-date"],
+    "A compatibility_date is required when publishing. Add one to your wrangler.toml file, or pass it in your terminal as --compatibility_date. See https://developers.cloudflare.com/workers/platform/compatibility-dates for more information."
+  );
+
   const triggers = props.triggers || config.triggers?.crons;
   const routes = props.routes || config.routes;
 
@@ -78,6 +86,18 @@ export default async function publish(props: Props): Promise<void> {
 
   const destination = await tmp.dir({ unsafeCleanup: true });
 
+  if (props.config.build?.command) {
+    // TODO: add a deprecation message here?
+    console.log("running:", props.config.build.command);
+    const buildCommandPieces = props.config.build.command.split(" ");
+    await execa(buildCommandPieces[0], buildCommandPieces.slice(1), {
+      stdout: "inherit",
+      stderr: "inherit",
+      ...(props.config.build?.cwd && { cwd: props.config.build.cwd }),
+    });
+  }
+
+  const moduleCollector = makeModuleCollector();
   const result = await esbuild.build({
     ...(props.public
       ? {
@@ -94,24 +114,17 @@ export default async function publish(props: Props): Promise<void> {
         }
       : { entryPoints: [file] }),
     bundle: true,
-    define: {
-      ...((props.polyfillNode ?? config.polyfill_node) && {
-        global: "globalThis",
-      }),
-    },
     nodePaths: props.public ? [path.join(__dirname, "../vendor")] : undefined,
     outdir: destination.path,
     external: ["__STATIC_CONTENT_MANIFEST"],
     format: "esm",
-    plugins:
-      props.polyfillNode ?? config.polyfill_node
-        ? [NodeGlobalsPolyfills({ buffer: true }), NodeModulesPolyfills()]
-        : undefined,
     sourcemap: true,
     metafile: true,
+    conditions: ["worker", "browser"],
     loader: {
       ".js": "jsx",
     },
+    plugins: [moduleCollector.plugin],
     ...(jsxFactory && { jsxFactory }),
     ...(jsxFragment && { jsxFragment }),
   });
@@ -121,7 +134,7 @@ export default async function publish(props: Props): Promise<void> {
       entryPoint ===
       (props.public
         ? path.join(path.dirname(file), "static-asset-facade.js")
-        : file)
+        : Object.keys(result.metafile.inputs)[0])
   );
 
   const { format } = props;
@@ -145,16 +158,16 @@ export default async function publish(props: Props): Promise<void> {
   }
 
   const content = await readFile(chunks[0], { encoding: "utf-8" });
-  destination.cleanup();
+  await destination.cleanup();
 
   // if config.migrations
   // get current migration tag
   let migrations;
   if ("migrations" in config) {
-    const scripts = await cfetch<{ id: string; migration_tag: string }[]>(
+    const scripts = await fetchResult<{ id: string; migration_tag: string }[]>(
       `/accounts/${accountId}/workers/scripts`
     );
-    const script = scripts.find((script) => script.id === scriptName);
+    const script = scripts.find(({ id }) => id === scriptName);
     if (script?.migration_tag) {
       // was already published once
       const foundIndex = config.migrations.findIndex(
@@ -162,7 +175,7 @@ export default async function publish(props: Props): Promise<void> {
       );
       if (foundIndex === -1) {
         console.warn(
-          `The published script ${scriptName} has a migration tag "${script.migration_tag}, which was not found in wrangler.toml. You may have already delated it. Applying all available migrations to the script...`
+          `The published script ${scriptName} has a migration tag "${script.migration_tag}, which was not found in wrangler.toml. You may have already deleted it. Applying all available migrations to the script...`
         );
         migrations = {
           old_tag: script.migration_tag,
@@ -196,7 +209,16 @@ export default async function publish(props: Props): Promise<void> {
         )
       : { manifest: undefined, namespace: undefined };
 
-  const envRootObj = props.env ? config.env[props.env] || {} : config;
+  const bindings: CfWorkerInit["bindings"] = {
+    kv_namespaces: envRootObj.kv_namespaces?.concat(
+      assets.namespace
+        ? { binding: "__STATIC_CONTENT", id: assets.namespace }
+        : []
+    ),
+    vars: envRootObj.vars,
+    durable_objects: envRootObj.durable_objects,
+    services: envRootObj.experimental_services,
+  };
 
   const worker: CfWorkerInit = {
     name: scriptName,
@@ -205,35 +227,17 @@ export default async function publish(props: Props): Promise<void> {
       content: content,
       type: bundle.type === "esm" ? "esm" : "commonjs",
     },
-    variables: {
-      ...(envRootObj?.vars || {}),
-      ...(envRootObj?.kv_namespaces || []).reduce(
-        (obj, { binding, preview_id: _preview_id, id }) => {
-          return { ...obj, [binding]: { namespaceId: id } };
-        },
-        {}
-      ),
-      ...(envRootObj?.durable_objects?.bindings || []).reduce(
-        (obj, { name, class_name, script_name }) => {
-          return {
-            ...obj,
-            [name]: { class_name, ...(script_name && { script_name }) },
-          };
-        },
-        {}
-      ),
-      ...(assets.namespace
-        ? { __STATIC_CONTENT: { namespaceId: assets.namespace } }
-        : {}),
-    },
+    bindings,
     ...(migrations && { migrations }),
-    modules: assets.manifest
-      ? [].concat({
-          name: "__STATIC_CONTENT_MANIFEST",
-          content: JSON.stringify(assets.manifest),
-          type: "text",
-        })
-      : [],
+    modules: moduleCollector.modules.concat(
+      assets.manifest
+        ? {
+            name: "__STATIC_CONTENT_MANIFEST",
+            content: JSON.stringify(assets.manifest),
+            type: "text",
+          }
+        : []
+    ),
     compatibility_date: config.compatibility_date,
     compatibility_flags: config.compatibility_flags,
     usage_model: config.usage_model,
@@ -250,8 +254,8 @@ export default async function publish(props: Props): Promise<void> {
     ? `/accounts/${accountId}/workers/services/${scriptName}/environments/${envName}`
     : `/accounts/${accountId}/workers/scripts/${scriptName}`;
 
-  // Upload the script so it has time to propogate.
-  const { available_on_subdomain } = await cfetch(
+  // Upload the script so it has time to propagate.
+  const { available_on_subdomain } = await fetchResult(
     `${workerUrl}?available_on_subdomain=true`,
     {
       method: "PUT",
@@ -265,7 +269,7 @@ export default async function publish(props: Props): Promise<void> {
   const deployments: Promise<string[]>[] = [];
 
   const userSubdomain = (
-    await cfetch<{ subdomain: string }>(
+    await fetchResult<{ subdomain: string }>(
       `/accounts/${accountId}/workers/subdomain`
     )
   ).subdomain;
@@ -279,7 +283,7 @@ export default async function publish(props: Props): Promise<void> {
   // TODO: Make this configurable.
   if (!available_on_subdomain) {
     deployments.push(
-      cfetch(`${workerUrl}/subdomain`, {
+      fetchResult(`${workerUrl}/subdomain`, {
         method: "POST",
         body: JSON.stringify({ enabled: true }),
         headers: {
@@ -291,8 +295,8 @@ export default async function publish(props: Props): Promise<void> {
         // This is to prevent an issue where a negative cache-hit
         // causes the subdomain to be unavailable for 30 seconds.
         // This is a temporary measure until we fix this on the edge.
-        .then((url) => {
-          sleep(3000);
+        .then(async (url) => {
+          await sleep(3000);
           return url;
         })
     );
@@ -303,7 +307,7 @@ export default async function publish(props: Props): Promise<void> {
   // Update routing table for the script.
   if (routes && routes.length) {
     deployments.push(
-      cfetch(`${workerUrl}/routes`, {
+      fetchResult(`${workerUrl}/routes`, {
         // TODO: PATCH will not delete previous routes on this script,
         // whereas PUT will. We need to decide on the default behaviour
         // and how to configure it.
@@ -328,7 +332,7 @@ export default async function publish(props: Props): Promise<void> {
   // TODO: rename this to `schedules`?
   if (triggers && triggers.length) {
     deployments.push(
-      cfetch(`${workerUrl}/schedules`, {
+      fetchResult(`${workerUrl}/schedules`, {
         // TODO: Unlike routes, this endpoint does not support PATCH.
         // So technically, this will override any previous schedules.
         // We should change the endpoint to support PATCH.

package/src/sites.tsx

@@ -1,11 +1,10 @@
-import { readdir, readFile } from "node:fs/promises";
+import crypto from "node:crypto";
 import { createReadStream } from "node:fs";
-import cfetch from "./cfetch";
+import * as path from "node:path";
+import { readdir, readFile } from "node:fs/promises";
+import { fetchResult } from "./cfetch";
 import { listNamespaceKeys, listNamespaces, putBulkKeyValue } from "./kv";
 
-import * as path from "path";
-import crypto from "node:crypto";
-
 async function* getFilesInFolder(dirPath: string): AsyncIterable<string> {
   const files = await readdir(dirPath, { withFileTypes: true });
   for (const file of files) {
@@ -54,7 +53,7 @@ async function createKVNamespaceIfNotAlreadyExisting(
 
   // else we make the namespace
   // TODO: use an export from ./kv
-  const json = await cfetch<{ id: string }>(
+  const json = await fetchResult<{ id: string }>(
     `/accounts/${accountId}/storage/kv/namespaces`,
     {
       method: "POST",
@@ -90,7 +89,11 @@ export async function syncAssets(
   );
 
   const manifest = {};
-  const upload = [];
+  const upload: {
+    key: string;
+    value: string;
+    base64: boolean;
+  }[] = [];
   // TODO: this can be more efficient by parallelising
   for await (const file of getFilesInFolder(dirPath)) {
     // TODO: "exclude:" config

package/src/tail.tsx

@@ -1,6 +1,6 @@
 import WebSocket from "ws";
-import cfetch from "./cfetch";
 import { version as packageVersion } from "../package.json";
+import { fetchResult } from "./cfetch";
 
 export type TailApiResponse = {
   id: string;
@@ -27,7 +27,9 @@ async function createTailButDontConnect(
 ): Promise<TailApiResponse> {
   const createTailUrl = makeCreateTailUrl(accountId, workerName);
   /// https://api.cloudflare.com/#worker-tail-logs-start-tail
-  return await cfetch<TailApiResponse>(createTailUrl, { method: "POST" });
+  return await fetchResult<TailApiResponse>(createTailUrl, {
+    method: "POST",
+  });
 }
 
 export async function createTail(
@@ -48,7 +50,7 @@ export async function createTail(
 
   // deletes the tail
   async function deleteTail() {
-    await cfetch(deleteUrl, { method: "DELETE" });
+    await fetchResult(deleteUrl, { method: "DELETE" });
   }
 
   const tail = new WebSocket(websocketUrl, "trace-v1", {