wrangler 2.0.3 → 2.0.7

package/src/proxy.ts

@@ -2,11 +2,13 @@ import { createServer as createHttpServer } from "node:http";
 import { connect } from "node:http2";
 import { createServer as createHttpsServer } from "node:https";
 import WebSocket from "faye-websocket";
+import { createHttpTerminator } from "http-terminator";
 import { useEffect, useRef, useState } from "react";
 import serveStatic from "serve-static";
 import { getHttpsOptions } from "./https-options";
 import { logger } from "./logger";
 import type { CfPreviewToken } from "./create-worker-preview";
+import type { HttpTerminator } from "http-terminator";
 import type {
   IncomingHttpHeaders,
   RequestListener,
@@ -67,6 +69,11 @@ function rewriteRemoteHostToLocalHostInHeaders(
   }
 }
 
+type PreviewProxy = {
+  server: HttpServer | HttpsServer;
+  terminator: HttpTerminator;
+};
+
 export function usePreviewServer({
   previewToken,
   publicRoot,
@@ -81,21 +88,26 @@ export function usePreviewServer({
   ip: string;
 }) {
   /** Creates an HTTP/1 proxy that sends requests over HTTP/2. */
-  const [proxyServer, setProxyServer] = useState<HttpServer | HttpsServer>();
+  const [proxy, setProxy] = useState<PreviewProxy>();
 
   /**
    * Create the instance of the local proxy server that will pass on
    * requests to the preview worker.
    */
   useEffect(() => {
-    if (proxyServer === undefined) {
+    if (proxy === undefined) {
       createProxyServer(localProtocol)
-        .then((proxy) => setProxyServer(proxy))
+        .then((server) => {
+          setProxy({
+            server,
+            terminator: createHttpTerminator({ server }),
+          });
+        })
         .catch(async (err) => {
           logger.error("Failed to create proxy server:", err);
         });
     }
-  }, [proxyServer, localProtocol]);
+  }, [proxy, localProtocol]);
 
   /**
    * When we're not connected / getting a fresh token on changes,
@@ -123,7 +135,7 @@ export function usePreviewServer({
   }
 
   useEffect(() => {
-    if (proxyServer === undefined) {
+    if (proxy === undefined) {
       return;
     }
 
@@ -138,8 +150,8 @@ export function usePreviewServer({
         // store the stream in a buffer so we can replay it later
         streamBufferRef.current.push({ stream, headers });
       };
-      proxyServer.on("stream", bufferStream);
-      cleanupListeners.push(() => proxyServer.off("stream", bufferStream));
+      proxy.server.on("stream", bufferStream);
+      cleanupListeners.push(() => proxy.server.off("stream", bufferStream));
 
       const bufferRequestResponse = (
         request: IncomingMessage,
@@ -149,9 +161,9 @@ export function usePreviewServer({
         requestResponseBufferRef.current.push({ request, response });
       };
 
-      proxyServer.on("request", bufferRequestResponse);
+      proxy.server.on("request", bufferRequestResponse);
       cleanupListeners.push(() =>
-        proxyServer.off("request", bufferRequestResponse)
+        proxy.server.off("request", bufferRequestResponse)
       );
       return () => {
         cleanupListeners.forEach((cleanup) => cleanup());
@@ -179,8 +191,8 @@ export function usePreviewServer({
       port,
       localProtocol
     );
-    proxyServer.on("stream", handleStream);
-    cleanupListeners.push(() => proxyServer.off("stream", handleStream));
+    proxy.server.on("stream", handleStream);
+    cleanupListeners.push(() => proxy.server.off("stream", handleStream));
 
     // flush and replay buffered streams
     streamBufferRef.current.forEach((buffer) =>
@@ -236,9 +248,9 @@ export function usePreviewServer({
       ? createHandleAssetsRequest(assetPath, handleRequest)
       : handleRequest;
 
-    proxyServer.on("request", actualHandleRequest);
+    proxy.server.on("request", actualHandleRequest);
     cleanupListeners.push(() =>
-      proxyServer.off("request", actualHandleRequest)
+      proxy.server.off("request", actualHandleRequest)
     );
 
     // flush and replay buffered requests
@@ -270,8 +282,8 @@ export function usePreviewServer({
         remoteWebsocketClient.close();
       });
     };
-    proxyServer.on("upgrade", handleUpgrade);
-    cleanupListeners.push(() => proxyServer.off("upgrade", handleUpgrade));
+    proxy.server.on("upgrade", handleUpgrade);
+    cleanupListeners.push(() => proxy.server.off("upgrade", handleUpgrade));
 
     return () => {
       cleanupListeners.forEach((cleanup) => cleanup());
@@ -281,7 +293,7 @@ export function usePreviewServer({
     publicRoot,
     port,
     localProtocol,
-    proxyServer,
+    proxy,
     // 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.
@@ -293,7 +305,7 @@ export function usePreviewServer({
   // containing component is mounted/unmounted.
   useEffect(() => {
     const abortController = new AbortController();
-    if (proxyServer === undefined) {
+    if (proxy === undefined) {
       return;
     }
 
@@ -303,8 +315,10 @@ export function usePreviewServer({
       abortSignal: abortController.signal,
     })
       .then(() => {
-        proxyServer.listen(port, ip);
-        logger.log(`⬣ Listening at ${localProtocol}://${ip}:${port}`);
+        proxy.server.on("listening", () => {
+          logger.log(`⬣ Listening at ${localProtocol}://${ip}:${port}`);
+        });
+        proxy.server.listen(port, ip);
       })
       .catch((err) => {
         if ((err as { code: string }).code !== "ABORT_ERR") {
@@ -313,10 +327,12 @@ export function usePreviewServer({
       });
 
     return () => {
-      proxyServer.close();
       abortController.abort();
+      // Running `proxy.server.close()` does not close open connections, preventing the process from exiting.
+      // So we use this `terminator` to close all the connections and force the server to shutdown.
+      proxy.terminator.terminate();
     };
-  }, [port, ip, proxyServer, localProtocol]);
+  }, [port, ip, proxy, localProtocol]);
 }
 
 function createHandleAssetsRequest(
@@ -404,7 +420,7 @@ export async function waitForPortToBeAvailable(
 ): Promise<void> {
   return new Promise((resolve, reject) => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (options.abortSignal as any).addEventListener("abort", () => {
+    options.abortSignal.addEventListener("abort", () => {
       const abortError = new Error("waitForPortToBeAvailable() aborted");
       (abortError as Error & { code: string }).code = "ABORT_ERR";
       doReject(abortError);

package/src/publish.ts

@@ -5,17 +5,26 @@ import { URLSearchParams } from "node:url";
 import tmp from "tmp-promise";
 import { bundleWorker } from "./bundle";
 import { fetchResult } from "./cfetch";
+import { printBindings } from "./config";
 import { createWorkerUploadForm } from "./create-worker-upload-form";
+import { confirm } from "./dialogs";
+import { getMigrationsToUpload } from "./durable";
 import { logger } from "./logger";
 import { syncAssets } from "./sites";
 import type { Config } from "./config";
+import type {
+  Route,
+  ZoneIdRoute,
+  ZoneNameRoute,
+  CustomDomainRoute,
+} from "./config/environment";
 import type { Entry } from "./entry";
 import type { AssetPaths } from "./sites";
 import type { CfWorkerInit } from "./worker";
 
 type Props = {
   config: Config;
-  accountId: string;
+  accountId: string | undefined;
   entry: Entry;
   rules: Config["rules"];
   name: string | undefined;
@@ -36,10 +45,178 @@ type Props = {
   dryRun: boolean | undefined;
 };
 
+type RouteObject = ZoneIdRoute | ZoneNameRoute | CustomDomainRoute;
+
 function sleep(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function renderRoute(route: Route): string {
+  let result = "";
+  if (typeof route === "string") {
+    result = route;
+  } else {
+    result = route.pattern;
+    const isCustomDomain = Boolean(
+      "custom_domain" in route && route.custom_domain
+    );
+    if (isCustomDomain && "zone_id" in route) {
+      result += ` (custom domain - zone id: ${route.zone_id})`;
+    } else if (isCustomDomain && "zone_name" in route) {
+      result += ` (custom domain - zone name: ${route.zone_name})`;
+    } else if (isCustomDomain) {
+      result += ` (custom domain)`;
+    } else if ("zone_id" in route) {
+      result += ` (zone id: ${route.zone_id})`;
+    } else if ("zone_name" in route) {
+      result += ` (zone name: ${route.zone_name})`;
+    }
+  }
+  return result;
+}
+
+// this function takes a string with quotes in it
+// (i.e. `hello "world", if that really is your name`)
+// and peels out the first instance of a substring
+// bounded by quotes (so, in the example above, `world`)
+//
+// this is useful because the /domains api will return
+// which domains conflicted in an error message, bounded
+// by a string, which we can use to provide helpful
+// messages to a user
+function getQuoteBoundedSubstring(content: string) {
+  const matches = content.split('"');
+  return matches[1] ?? "";
+}
+
+function isOriginConflictError(
+  e: unknown
+): e is { code: 100116; message: string; notes: Array<{ text: string }> } {
+  return (
+    typeof e === "object" &&
+    e !== null &&
+    (e as { code: number }).code === 100116
+  );
+}
+
+function isDNSConflictError(
+  e: unknown
+): e is { code: 100117; message: string; notes: Array<{ text: string }> } {
+  return (
+    typeof e === "object" &&
+    e !== null &&
+    (e as { code: number }).code === 100117
+  );
+}
+
+// empty error class to throw and then explicitly catch via `instanceof`
+class CustomDomainOverrideRejected extends Error {}
+
+// publishing to custom domains involves a few more steps than just updating
+// the routing table, and thus the api implementing it is fairly defensive -
+// it will error eagerly on conflicts against existing domains or existing
+// managed DNS records
+//
+// however, you can pass params to override the errors. we start on the
+// defensive path, and if one of these errors occur, we prompt the user
+// for confirmation that they do indeed want to override the conflicts, and
+// then retry the request with the right override added
+//
+// if a user does not confirm that they want to override, we skip publishing
+// to these custom domains, but continue on through the rest of the
+// publish stage
+function publishCustomDomains(
+  workerUrl: string,
+  domains: Array<RouteObject>
+): Promise<string[]> {
+  const config = {
+    override_scope: true,
+    override_existing_origin: false,
+    override_existing_dns_record: false,
+  };
+  const origins = domains.map((domainRoute) => {
+    return {
+      hostname: domainRoute.pattern,
+      zone_id: "zone_id" in domainRoute ? domainRoute.zone_id : undefined,
+      zone_name: "zone_name" in domainRoute ? domainRoute.zone_name : undefined,
+    };
+  });
+
+  if (!process.stdout.isTTY) {
+    // running in non-interactive mode.
+    // existing origins / dns records are not indicative of errors,
+    // so we aggressively update rather than aggressively fail
+    config.override_existing_origin = true;
+    config.override_existing_dns_record = true;
+  }
+
+  // Mixing promise chains with async/await is funky, but it allows us to keep related
+  // logic synchronous-looking (i.e. prompting for confirmation and then re-requesting)
+  // while retaining the flexibility of promise chain fall-throughs. We can group error
+  // handling logic in dedicated catch calls, and all we have to do is re-throw an
+  // error and it will pass down to the next catch call
+  return fetchResult(`${workerUrl}/domains`, {
+    method: "PUT",
+    body: JSON.stringify({ ...config, origins }),
+    headers: {
+      "Content-Type": "application/json",
+    },
+  })
+    .catch(async (err) => {
+      if (isOriginConflictError(err)) {
+        const conflictingOrigins = getQuoteBoundedSubstring(err.notes[0].text);
+        const shouldContinue = await confirm(
+          `Custom Domains already exist for these domains: "${conflictingOrigins}"\nUpdate them to point to this script instead?`
+        );
+        if (!shouldContinue) {
+          throw new CustomDomainOverrideRejected();
+        }
+        config.override_existing_origin = true;
+        await fetchResult(`${workerUrl}/domains`, {
+          method: "PUT",
+          body: JSON.stringify({ ...config, origins }),
+          headers: {
+            "Content-Type": "application/json",
+          },
+        });
+      } else {
+        throw err;
+      }
+    })
+    .catch(async (err) => {
+      if (isDNSConflictError(err)) {
+        const conflictingOrigins = getQuoteBoundedSubstring(err.notes[0].text);
+        const shouldContinue = await confirm(
+          `You already have conflicting DNS records for these domains: "${conflictingOrigins}"\nUpdate them to point to this script instead?`
+        );
+        if (!shouldContinue) {
+          throw new CustomDomainOverrideRejected();
+        }
+        config.override_existing_dns_record = true;
+        await fetchResult(`${workerUrl}/domains`, {
+          method: "PUT",
+          body: JSON.stringify({ ...config, origins }),
+          headers: {
+            "Content-Type": "application/json",
+          },
+        });
+      } else {
+        throw err;
+      }
+    })
+    .then(() => domains.map((domain) => renderRoute(domain)))
+    .catch((err) => {
+      if (err instanceof CustomDomainOverrideRejected) {
+        return [
+          domains.length > 1
+            ? `Publishing to ${domains.length} Custom Domains was skipped, fix conflicts and try again`
+            : `Publishing to Custom Domain "${domains[0].pattern}" was skipped, fix conflict and try again`,
+        ];
+      }
+      throw err;
+    });
+}
+
 export default async function publish(props: Props): Promise<void> {
   // TODO: warn if git/hg has uncommitted changes
   const { config, accountId } = props;
@@ -52,6 +229,25 @@ export default async function publish(props: Props): Promise<void> {
   const triggers = props.triggers || config.triggers?.crons;
   const routes =
     props.routes ?? config.routes ?? (config.route ? [config.route] : []) ?? [];
+  const routesOnly: Array<Route> = [];
+  const customDomainsOnly: Array<RouteObject> = [];
+  for (const route of routes) {
+    if (typeof route !== "string" && route.custom_domain) {
+      if (route.pattern.includes("*")) {
+        throw new Error(
+          `Cannot use "${route.pattern}" as a Custom Domain; wildcard operators (*) are not allowed`
+        );
+      }
+      if (route.pattern.includes("/")) {
+        throw new Error(
+          `Cannot use "${route.pattern}" as a Custom Domain; paths are not allowed`
+        );
+      }
+      customDomainsOnly.push(route);
+    } else {
+      routesOnly.push(route);
+    }
+  }
 
   // deployToWorkersDev defaults to true only if there aren't any routes defined
   const deployToWorkersDev = config.workers_dev ?? routes.length === 0;
@@ -143,103 +339,19 @@ export default async function publish(props: Props): Promise<void> {
       }
     );
 
-    // Some validation of durable objects + migrations
-    if (config.durable_objects.bindings.length > 0) {
-      // intrinsic [durable_objects] implies [migrations]
-      const exportedDurableObjects = config.durable_objects.bindings.filter(
-        (binding) => !binding.script_name
-      );
-      if (exportedDurableObjects.length > 0 && config.migrations.length === 0) {
-        logger.warn(
-          `In wrangler.toml, you have configured [durable_objects] exported by this Worker (${exportedDurableObjects.map(
-            (durable) => durable.class_name
-          )}), but no [migrations] for them. This may not work as expected until you add a [migrations] section to your wrangler.toml. Refer to https://developers.cloudflare.com/workers/learning/using-durable-objects/#durable-object-migrations-in-wranglertoml for more details.`
-        );
-      }
-    }
-
     const content = readFileSync(resolvedEntryPointPath, {
       encoding: "utf-8",
     });
 
-    // if config.migrations
-    let migrations;
-    if (config.migrations.length > 0) {
-      // get current migration tag
-      type ScriptData = { id: string; migration_tag?: string };
-      let script: ScriptData | undefined;
-      if (!props.legacyEnv) {
-        try {
-          if (props.env) {
-            const scriptData = await fetchResult<{
-              script: ScriptData;
-            }>(
-              `/accounts/${accountId}/workers/services/${scriptName}/environments/${props.env}`
-            );
-            script = scriptData.script;
-          } else {
-            const scriptData = await fetchResult<{
-              default_environment: {
-                script: ScriptData;
-              };
-            }>(`/accounts/${accountId}/workers/services/${scriptName}`);
-            script = scriptData.default_environment.script;
-          }
-        } catch (err) {
-          if (
-            ![
-              10090, // corresponds to workers.api.error.service_not_found, so the script wasn't previously published at all
-              10092, // workers.api.error.environment_not_found, so the script wasn't published to this environment yet
-            ].includes((err as { code: number }).code)
-          ) {
-            throw err;
-          }
-          // else it's a 404, no script found, and we can proceed
-        }
-      } else {
-        const scripts = await fetchResult<ScriptData[]>(
-          `/accounts/${accountId}/workers/scripts`
-        );
-        script = scripts.find(({ id }) => id === scriptName);
-      }
-
-      if (script?.migration_tag) {
-        // was already published once
-        const scriptMigrationTag = script.migration_tag;
-        const foundIndex = config.migrations.findIndex(
-          (migration) => migration.tag === scriptMigrationTag
-        );
-        if (foundIndex === -1) {
-          logger.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 {
-          if (foundIndex !== config.migrations.length - 1) {
-            // there are new migrations to send up
-            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, we're up to date, no migrations to send
-        }
-      } else {
-        // first time publishing durable objects to this script,
-        // so we send all the migrations
-        migrations = {
-          new_tag: config.migrations[config.migrations.length - 1].tag,
-          steps: config.migrations.map(({ tag: _tag, ...rest }) => rest),
-        };
-      }
-    }
+    // durable object migrations
+    const migrations = !props.dryRun
+      ? await getMigrationsToUpload(scriptName, {
+          accountId,
+          config,
+          legacyEnv: props.legacyEnv,
+          env: props.env,
+        })
+      : undefined;
 
     const assets = await syncAssets(
       accountId,
@@ -271,6 +383,7 @@ export default async function publish(props: Props): Promise<void> {
       data_blobs: config.data_blobs,
       durable_objects: config.durable_objects,
       r2_buckets: config.r2_buckets,
+      services: config.services,
       unsafe: config.unsafe?.bindings,
     };
 
@@ -298,6 +411,13 @@ export default async function publish(props: Props): Promise<void> {
       usage_model: config.usage_model,
     };
 
+    const withoutStaticAssets = {
+      ...bindings,
+      kv_namespaces: config.kv_namespaces,
+      text_blobs: config.text_blobs,
+    };
+    printBindings(withoutStaticAssets);
+
     if (!props.dryRun) {
       // Upload the script so it has time to propagate.
       // We can also now tell whether available_on_subdomain is set
@@ -324,6 +444,7 @@ export default async function publish(props: Props): Promise<void> {
     logger.log(`--dry-run: exiting now.`);
     return;
   }
+  assert(accountId, "Missing accountId");
 
   const uploadMs = Date.now() - start;
   const deployments: Promise<string[]>[] = [];
@@ -374,13 +495,13 @@ export default async function publish(props: Props): Promise<void> {
   logger.log("Uploaded", workerName, formatTime(uploadMs));
 
   // Update routing table for the script.
-  if (routes.length > 0) {
+  if (routesOnly.length > 0) {
     deployments.push(
       fetchResult(`${workerUrl}/routes`, {
         // Note: PUT will delete previous routes on this script.
         method: "PUT",
         body: JSON.stringify(
-          routes.map((route) =>
+          routesOnly.map((route) =>
             typeof route !== "object" ? { pattern: route } : route
           )
         ),
@@ -388,29 +509,22 @@ export default async function publish(props: Props): Promise<void> {
           "Content-Type": "application/json",
         },
       }).then(() => {
-        if (routes.length > 10) {
-          return routes
+        if (routesOnly.length > 10) {
+          return routesOnly
             .slice(0, 9)
-            .map((route) =>
-              typeof route === "string"
-                ? route
-                : "zone_id" in route
-                ? `${route.pattern} (zone id: ${route.zone_id})`
-                : `${route.pattern} (zone name: ${route.zone_name})`
-            )
-            .concat([`...and ${routes.length - 10} more routes`]);
+            .map((route) => renderRoute(route))
+            .concat([`...and ${routesOnly.length - 10} more routes`]);
         }
-        return routes.map((route) =>
-          typeof route === "string"
-            ? route
-            : "zone_id" in route
-            ? `${route.pattern} (zone id: ${route.zone_id})`
-            : `${route.pattern} (zone name: ${route.zone_name})`
-        );
+        return routesOnly.map((route) => renderRoute(route));
       })
     );
   }
 
+  // Update custom domains for the script
+  if (customDomainsOnly.length > 0) {
+    deployments.push(publishCustomDomains(workerUrl, customDomainsOnly));
+  }
+
   // Configure any schedules for the script.
   // TODO: rename this to `schedules`?
   if (triggers && triggers.length) {

package/src/sites.tsx

@@ -1,13 +1,14 @@
+import assert from "node:assert";
 import { readdir, readFile, stat } from "node:fs/promises";
 import * as path from "node:path";
 import ignore from "ignore";
 import xxhash from "xxhash-wasm";
 import {
-  createNamespace,
-  listNamespaceKeys,
-  listNamespaces,
-  putBulkKeyValue,
-  deleteBulkKeyValue,
+  createKVNamespace,
+  listKVNamespaceKeys,
+  listKVNamespaces,
+  putKVBulkKeyValue,
+  deleteKVBulkKeyValue,
 } from "./kv";
 import { logger } from "./logger";
 import type { Config } from "./config";
@@ -75,14 +76,14 @@ async function createKVNamespaceIfNotAlreadyExisting(
 ) {
   // check if it already exists
   // TODO: this is super inefficient, should be made better
-  const namespaces = await listNamespaces(accountId);
+  const namespaces = await listKVNamespaces(accountId);
   const found = namespaces.find((x) => x.title === title);
   if (found) {
     return { created: false, id: found.id };
   }
 
   // else we make the namespace
-  const id = await createNamespace(accountId, title);
+  const id = await createKVNamespace(accountId, title);
   logger.log(`🌀 Created namespace for Workers Site "${title}"`);
 
   return {
@@ -103,7 +104,7 @@ async function createKVNamespaceIfNotAlreadyExisting(
  * asset in the KV namespace.
  */
 export async function syncAssets(
-  accountId: string,
+  accountId: string | undefined,
   scriptName: string,
   siteAssets: AssetPaths | undefined,
   preview: boolean,
@@ -120,6 +121,7 @@ export async function syncAssets(
     logger.log("(Note: doing a dry run, not uploading or deleting anything.)");
     return { manifest: undefined, namespace: undefined };
   }
+  assert(accountId, "Missing accountId");
 
   const title = `__${scriptName}-workers_sites_assets${
     preview ? "_preview" : ""
@@ -131,7 +133,7 @@ export async function syncAssets(
   );
 
   // let's get all the keys in this namespace
-  const namespaceKeysResponse = await listNamespaceKeys(accountId, namespace);
+  const namespaceKeysResponse = await listKVNamespaceKeys(accountId, namespace);
   const namespaceKeys = new Set(namespaceKeysResponse.map((x) => x.name));
 
   const manifest: Record<string, string> = {};
@@ -185,14 +187,9 @@ export async function syncAssets(
 
   await Promise.all([
     // upload all the new assets
-    putBulkKeyValue(accountId, namespace, toUpload, () => {}),
+    putKVBulkKeyValue(accountId, namespace, toUpload),
     // delete all the unused assets
-    deleteBulkKeyValue(
-      accountId,
-      namespace,
-      Array.from(namespaceKeys),
-      () => {}
-    ),
+    deleteKVBulkKeyValue(accountId, namespace, Array.from(namespaceKeys)),
   ]);
 
   logger.log("↗️  Done syncing assets");