wrangler 0.0.0-e14e589 → 0.0.0-e1c615f

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,12 +1,14 @@
-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";
 
 type CfScriptFormat = void | "modules" | "service-worker";
@@ -22,6 +24,8 @@ type Props = {
   triggers?: (string | number)[];
   routes?: (string | number)[];
   legacyEnv?: boolean;
+  jsxFactory: void | string;
+  jsxFragment: void | string;
 };
 
 function sleep(ms: number) {
@@ -47,19 +51,25 @@ export default async function publish(props: Props): Promise<void> {
   const triggers = props.triggers || config.triggers?.crons;
   const routes = props.routes || config.routes;
 
+  const jsxFactory = props.jsxFactory || config.jsx_factory;
+  const jsxFragment = props.jsxFragment || config.jsx_fragment;
+
   assert(config.account_id, "missing account id");
 
+  let scriptName = props.name || config.name;
+  assert(
+    scriptName,
+    'You need to provide a name when publishing a worker. Either pass it as a cli arg with `--name <name>` or in your config file as `name = "<name>"`'
+  );
+
   let file: string;
   if (props.script) {
     file = props.script;
-    assert(props.name, "name is required when using script");
   } else {
     assert(build?.upload?.main, "missing main file");
-    assert(config.name, "missing name");
     file = path.join(path.dirname(__path__), build.upload.main);
   }
 
-  let scriptName = props.script ? props.name : config.name;
   if (props.legacyEnv) {
     scriptName += props.env ? `-${props.env}` : "";
   }
@@ -67,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
       ? {
@@ -89,6 +111,13 @@ export default async function publish(props: Props): Promise<void> {
     format: "esm",
     sourcemap: true,
     metafile: true,
+    conditions: ["worker", "browser"],
+    loader: {
+      ".js": "jsx",
+    },
+    plugins: [moduleCollector.plugin],
+    ...(jsxFactory && { jsxFactory }),
+    ...(jsxFragment && { jsxFragment }),
   });
 
   const chunks = Object.entries(result.metafile.outputs).find(
@@ -120,7 +149,47 @@ 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 fetchResult<{ id: string; migration_tag: string }[]>(
+      `/accounts/${accountId}/workers/scripts`
+    );
+    const script = scripts.find(({ id }) => id === scriptName);
+    if (script?.migration_tag) {
+      // was already published once
+      const foundIndex = config.migrations.findIndex(
+        (migration) => migration.tag === script.migration_tag
+      );
+      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 deleted it. Applying all available migrations to the script...`
+        );
+        migrations = {
+          old_tag: script.migration_tag,
+          new_tag: config.migrations[config.migrations.length - 1].tag,
+          steps: config.migrations.map(({ tag: _tag, ...rest }) => rest),
+        };
+      } else {
+        migrations = {
+          old_tag: script.migration_tag,
+          new_tag: config.migrations[config.migrations.length - 1].tag,
+          steps: config.migrations
+            .slice(foundIndex + 1)
+            .map(({ tag: _tag, ...rest }) => rest),
+        };
+      }
+    } else {
+      migrations = {
+        new_tag: config.migrations[config.migrations.length - 1].tag,
+        steps: config.migrations.map(({ tag: _tag, ...rest }) => rest),
+      };
+    }
+  }
+
   const assets =
     props.public || props.site || props.config.site?.bucket // TODO: allow both
       ? await syncAssets(
@@ -131,42 +200,45 @@ export default async function publish(props: Props): Promise<void> {
         )
       : { manifest: undefined, namespace: undefined };
 
-  const envRootObj = props.env ? config[`env.${props.env}`] : config;
+  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,
     main: {
-      name: scriptName,
+      name: path.basename(chunks[0]),
       content: content,
-      type:
-        (bundle.type === "esm" ? "modules" : "service-worker") === "modules"
-          ? "esm"
-          : "commonjs",
+      type: bundle.type === "esm" ? "esm" : "commonjs",
     },
-    variables: {
-      ...(envRootObj?.vars || {}),
-      ...(envRootObj?.kv_namespaces || []).reduce(
-        (obj, { binding, preview_id, id }) => {
-          return { ...obj, [binding]: { namespaceId: id } };
-        },
-        {}
-      ),
-      ...(assets.namespace
-        ? { __STATIC_CONTENT: { namespaceId: assets.namespace } }
-        : {}),
-    },
-    modules: assets.manifest
-      ? [].concat({
-          name: "__STATIC_CONTENT_MANIFEST",
-          content: JSON.stringify(assets.manifest),
-          type: "text",
-        })
-      : [],
+    bindings,
+    ...(migrations && { migrations }),
+    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,
   };
 
   const start = Date.now();
-  const formatTime = (duration) => {
+  function formatTime(duration: number) {
     return `(${(duration / 1000).toFixed(2)} sec)`;
-  };
+  }
 
   const notProd = !props.legacyEnv && props.env;
   const workerName = notProd ? `${scriptName} (${envName})` : scriptName;
@@ -174,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",
@@ -189,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;
@@ -203,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: {
@@ -215,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;
         })
     );
@@ -227,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.
@@ -252,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",
@@ -76,7 +75,7 @@ export async function syncAssets(
   scriptName: string,
   dirPath: string,
   preview: boolean,
-  env?: string
+  _env?: string
 ) {
   const title = `__${scriptName}_sites_assets${preview ? "_preview" : ""}`;
   const { id: namespace } = await createKVNamespaceIfNotAlreadyExisting(

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,13 +27,15 @@ 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(
   accountId: string,
   workerName: string,
-  filters: Filters
+  _filters: Filters
 ): Promise<{
   tail: WebSocket;
   expiration: Date;
@@ -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",