wrangler 0.0.0-ece06ea → 0.0.0-eebdb6c

package/src/proxy.ts

@@ -0,0 +1,103 @@
+import { connect } from "node:http2";
+import { createServer } from "node:http";
+import type { Server, IncomingHttpHeaders, RequestListener } from "node:http";
+import WebSocket from "faye-websocket";
+import serveStatic from "serve-static";
+
+export interface HttpProxyInit {
+  host: string;
+  assetPath?: string | null;
+  onRequest?: (headers: IncomingHttpHeaders) => void;
+  onResponse?: (headers: IncomingHttpHeaders) => void;
+}
+
+/**
+ * Creates a HTTP/1 proxy that sends requests over HTTP/2.
+ */
+export function createHttpProxy(init: HttpProxyInit): Server {
+  const { host, assetPath, onRequest = () => {}, onResponse = () => {} } = init;
+  const remote = connect(`https://${host}`);
+  const local = createServer();
+  // HTTP/2 -> HTTP/2
+  local.on("stream", (stream, headers: IncomingHttpHeaders) => {
+    onRequest(headers);
+    headers[":authority"] = host;
+    const request = stream.pipe(remote.request(headers));
+    request.on("response", (responseHeaders: IncomingHttpHeaders) => {
+      onResponse(responseHeaders);
+      stream.respond(responseHeaders);
+      request.pipe(stream, { end: true });
+    });
+  });
+  // HTTP/1 -> HTTP/2
+  const handleRequest: RequestListener = (message, response) => {
+    const { httpVersionMajor, headers, method, url } = message;
+    if (httpVersionMajor >= 2) {
+      return; // Already handled by the "stream" event.
+    }
+    onRequest(headers);
+    headers[":method"] = method;
+    headers[":path"] = url;
+    headers[":authority"] = 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"];
+      onResponse(responseHeaders);
+      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.
+  if (assetPath) {
+    const handleAsset = serveStatic(assetPath, {
+      cacheControl: false,
+    });
+    local.on("request", (request, response) => {
+      handleAsset(request, response, () => {
+        handleRequest(request, response);
+      });
+    });
+  } else {
+    local.on("request", handleRequest);
+  }
+  // HTTP/1 -> WebSocket (over HTTP/1)
+  local.on("upgrade", (message, socket, body) => {
+    const { headers, url } = message;
+    onRequest(headers);
+    headers["host"] = host;
+    const localWebsocket = new WebSocket(message, socket, body);
+    // TODO(soon): Custom WebSocket protocol is not working?
+    const remoteWebsocketClient = new WebSocket.Client(
+      `wss://${host}${url}`,
+      [],
+      { headers }
+    );
+    localWebsocket.pipe(remoteWebsocketClient).pipe(localWebsocket);
+  });
+  remote.on("close", () => {
+    local.close();
+  });
+  return local;
+}
+
+const HTTP1_HEADERS = new Set([
+  "host",
+  "connection",
+  "upgrade",
+  "keep-alive",
+  "proxy-connection",
+  "transfer-encoding",
+  "http2-settings",
+]);

package/src/publish.ts

@@ -1,15 +1,15 @@
-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";
 
@@ -26,7 +26,6 @@ type Props = {
   legacyEnv?: boolean;
   jsxFactory: void | string;
   jsxFragment: void | string;
-  polyfillNode: void | boolean;
 };
 
 function sleep(ms: number) {
@@ -78,6 +77,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 +105,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 }),
   });
@@ -145,16 +149,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 +166,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,
@@ -197,6 +201,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 +219,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 +246,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 +261,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 +275,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 +287,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 +299,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 +324,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",

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", {

package/src/user.tsx

@@ -578,19 +578,16 @@ export async function getAuthURL(scopes?: string[]): Promise<string> {
  * Refresh an access token from the remote service.
  */
 async function exchangeRefreshTokenForAccessToken(): Promise<AccessContext> {
-  const { refreshToken } = LocalState;
-
-  if (!refreshToken) {
+  if (!LocalState.refreshToken) {
     console.warn("No refresh token is present.");
   }
 
-  const url = TOKEN_URL;
   const body =
     `grant_type=refresh_token&` +
-    `refresh_token=${refreshToken?.value}&` +
+    `refresh_token=${LocalState.refreshToken?.value}&` +
     `client_id=${CLIENT_ID}`;
 
-  const response = await fetch(url, {
+  const response = await fetch(TOKEN_URL, {
     method: "POST",
     body,
     headers: {
@@ -617,10 +614,9 @@ async function exchangeRefreshTokenForAccessToken(): Promise<AccessContext> {
       LocalState.accessToken = accessToken;
 
       if (refresh_token) {
-        const refreshToken: RefreshToken = {
+        LocalState.refreshToken = {
           value: refresh_token,
         };
-        LocalState.refreshToken = refreshToken;
       }
 
       if (scope) {
@@ -666,7 +662,6 @@ async function exchangeAuthCodeForAccessToken(): Promise<AccessContext> {
     console.warn("No authorization grant code is being passed.");
   }
 
-  const url = TOKEN_URL;
   const body =
     `grant_type=authorization_code&` +
     `code=${encodeURIComponent(authorizationCode || "")}&` +
@@ -674,7 +669,7 @@ async function exchangeAuthCodeForAccessToken(): Promise<AccessContext> {
     `client_id=${encodeURIComponent(CLIENT_ID)}&` +
     `code_verifier=${codeVerifier}`;
 
-  const response = await fetch(url, {
+  const response = await fetch(TOKEN_URL, {
     method: "POST",
     body,
     headers: {
@@ -709,10 +704,9 @@ async function exchangeAuthCodeForAccessToken(): Promise<AccessContext> {
   LocalState.accessToken = accessToken;
 
   if (refresh_token) {
-    const refreshToken: RefreshToken = {
+    LocalState.refreshToken = {
       value: refresh_token,
     };
-    LocalState.refreshToken = refreshToken;
   }
 
   if (scope) {
@@ -816,7 +810,7 @@ export async function loginOrRefreshIfRequired(): Promise<boolean> {
 
 export async function login(props?: LoginProps): Promise<boolean> {
   const urlToOpen = await getAuthURL(props?.scopes);
-  open(urlToOpen);
+  await open(urlToOpen);
   // TODO: log url only if on system where it's unreliable/unavailable
   // console.log(`💁 Opened ${urlToOpen}`);
   let server;
@@ -921,15 +915,14 @@ export async function refreshToken(): Promise<boolean> {
 
 export async function logout(): Promise<void> {
   throwIfNotInitialised();
-  const { refreshToken } = LocalState;
-  if (!refreshToken) {
+  if (!LocalState.refreshToken) {
     console.log("Not logged in, exiting...");
     return;
   }
   const body =
     `client_id=${encodeURIComponent(CLIENT_ID)}&` +
     `token_type_hint=refresh_token&` +
-    `token=${encodeURIComponent(refreshToken?.value || "")}`;
+    `token=${encodeURIComponent(LocalState.refreshToken?.value || "")}`;
 
   const response = await fetch(REVOKE_URL, {
     method: "POST",