wrangler 2.0.6 → 2.0.7

package/src/parse.ts

@@ -62,8 +62,6 @@ export class ParseError extends Error implements Message {
   }
 }
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
 const TOML_ERROR_NAME = "TomlError";
 const TOML_ERROR_SUFFIX = " at row ";
 
@@ -78,7 +76,7 @@ type TomlError = Error & {
 export function parseTOML(input: string, file?: string): TOML.JsonMap | never {
   try {
     // Normalize CRLF to LF to avoid hitting https://github.com/iarna/iarna-toml/issues/33.
-    const normalizedInput = input.replace(/\r\n$/g, "\n");
+    const normalizedInput = input.replace(/\r\n/g, "\n");
     return TOML.parse(normalizedInput);
   } catch (err) {
     const { name, message, line, col } = err as TomlError;
@@ -100,10 +98,29 @@ export function parseTOML(input: string, file?: string): TOML.JsonMap | never {
 
 const JSON_ERROR_SUFFIX = " in JSON at position ";
 
+/**
+ * A minimal type describing a package.json file.
+ */
+export type PackageJSON = {
+  devDependencies?: Record<string, unknown>;
+  dependencies?: Record<string, unknown>;
+  scripts?: Record<string, unknown>;
+};
+
+/**
+ * A typed version of `parseJSON()`.
+ */
+export function parsePackageJSON<T extends PackageJSON = PackageJSON>(
+  input: string,
+  file?: string
+): T {
+  return parseJSON<T>(input, file);
+}
+
 /**
  * A wrapper around `JSON.parse` that throws a `ParseError`.
  */
-export function parseJSON(input: string, file?: string): any {
+export function parseJSON<T>(input: string, file?: string): T {
   try {
     return JSON.parse(input);
   } catch (err) {

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,8 +5,10 @@ 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";
@@ -337,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 (!props.dryRun && 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,
@@ -493,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

package/src/sites.tsx

@@ -187,14 +187,9 @@ export async function syncAssets(
 
   await Promise.all([
     // upload all the new assets
-    putKVBulkKeyValue(accountId, namespace, toUpload, () => {}),
+    putKVBulkKeyValue(accountId, namespace, toUpload),
     // delete all the unused assets
-    deleteKVBulkKeyValue(
-      accountId,
-      namespace,
-      Array.from(namespaceKeys),
-      () => {}
-    ),
+    deleteKVBulkKeyValue(accountId, namespace, Array.from(namespaceKeys)),
   ]);
 
   logger.log("↗️  Done syncing assets");

package/templates/new-worker.ts

@@ -8,8 +8,23 @@
  * Learn more at https://developers.cloudflare.com/workers/
  */
 
+export interface Env {
+  // Example binding to KV. Learn more at https://developers.cloudflare.com/workers/runtime-apis/kv/
+  // MY_KV_NAMESPACE: KVNamespace;
+  //
+  // Example binding to Durable Object. Learn more at https://developers.cloudflare.com/workers/runtime-apis/durable-objects/
+  // MY_DURABLE_OBJECT: DurableObjectNamespace;
+  //
+  // Example binding to R2. Learn more at https://developers.cloudflare.com/workers/runtime-apis/r2/
+  // MY_BUCKET: R2Bucket;
+}
+
 export default {
-  async fetch(request: Request): Promise<Response> {
+  async fetch(
+    request: Request,
+    env: Env,
+    ctx: ExecutionContext
+  ): Promise<Response> {
     return new Response("Hello World!");
   },
 };