wrangler 0.0.0-e88a54e → 0.0.0-e95e5a0

package/src/parse.ts

@@ -75,7 +75,7 @@ type TomlError = Error & {
 /**
  * A wrapper around `TOML.parse` that throws a `ParseError`.
  */
-export function parseTOML(input: string, file?: string): object {
+export function parseTOML(input: string, file?: string): TOML.JsonMap | never {
   try {
     return TOML.parse(input);
   } catch (err) {

package/src/proxy.ts

@@ -5,7 +5,7 @@ import WebSocket from "faye-websocket";
 import { useEffect, useRef, useState } from "react";
 import serveStatic from "serve-static";
 import { getHttpsOptions } from "./https-options";
-import { reportError } from "./reporting";
+import { logger } from "./logger";
 import type { CfPreviewToken } from "./create-worker-preview";
 import type {
   IncomingHttpHeaders,
@@ -75,7 +75,7 @@ export function usePreviewServer({
   ip,
 }: {
   previewToken: CfPreviewToken | undefined;
-  publicRoot: undefined | string;
+  publicRoot: string | undefined;
   localProtocol: "https" | "http";
   localPort: number;
   ip: string;
@@ -92,8 +92,7 @@ export function usePreviewServer({
       createProxyServer(localProtocol)
         .then((proxy) => setProxyServer(proxy))
         .catch(async (err) => {
-          console.error("Failed to create proxy server.", err);
-          await reportError(err);
+          logger.error("Failed to create proxy server:", err);
         });
     }
   }, [proxyServer, localProtocol]);
@@ -211,6 +210,10 @@ export function usePreviewServer({
       const request = message.pipe(remote.request(headers));
       request.on("response", (responseHeaders) => {
         const status = responseHeaders[":status"] ?? 500;
+
+        // log all requests to terminal
+        logger.log(new Date().toLocaleTimeString(), method, url, status);
+
         rewriteRemoteHostToLocalHostInHeaders(
           responseHeaders,
           previewToken.host,
@@ -289,21 +292,29 @@ export function usePreviewServer({
   // Start/stop the server whenever the
   // containing component is mounted/unmounted.
   useEffect(() => {
+    const abortController = new AbortController();
     if (proxyServer === undefined) {
       return;
     }
 
-    waitForPortToBeAvailable(port, { retryPeriod: 200, timeout: 2000 })
+    waitForPortToBeAvailable(port, {
+      retryPeriod: 200,
+      timeout: 2000,
+      abortSignal: abortController.signal,
+    })
       .then(() => {
         proxyServer.listen(port, ip);
-        console.log(`⬣ Listening at ${localProtocol}://${ip}:${port}`);
+        logger.log(`⬣ Listening at ${localProtocol}://${ip}:${port}`);
       })
       .catch((err) => {
-        console.error(`⬣ Failed to start server: ${err}`);
+        if ((err as { code: string }).code !== "ABORT_ERR") {
+          logger.error(`Failed to start server: ${err}`);
+        }
       });
 
     return () => {
       proxyServer.close();
+      abortController.abort();
     };
   }, [port, ip, proxyServer, localProtocol]);
 }
@@ -342,18 +353,9 @@ async function createProxyServer(
       : createHttpServer();
 
   return server
-    .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(
+      logger.log(
         new Date().toLocaleTimeString(),
         req.method,
         req.url,
@@ -363,7 +365,7 @@ async function createProxyServer(
     })
     .on("error", (err) => {
       // log all connection errors
-      console.error(new Date().toLocaleTimeString(), err);
+      logger.error(new Date().toLocaleTimeString(), err);
     });
 }
 
@@ -398,9 +400,16 @@ function createStreamHandler(
  */
 export async function waitForPortToBeAvailable(
   port: number,
-  options: { retryPeriod: number; timeout: number }
+  options: { retryPeriod: number; timeout: number; abortSignal: AbortSignal }
 ): Promise<void> {
   return new Promise((resolve, reject) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (options.abortSignal as any).addEventListener("abort", () => {
+      const abortError = new Error("waitForPortToBeAvailable() aborted");
+      (abortError as Error & { code: string }).code = "ABORT_ERR";
+      doReject(abortError);
+    });
+
     const timeout = setTimeout(() => {
       doReject(new Error(`Timed out waiting for port ${port}`));
     }, options.timeout);

package/src/publish.ts

@@ -1,11 +1,12 @@
 import assert from "node:assert";
-import { readFileSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { URLSearchParams } from "node:url";
 import tmp from "tmp-promise";
 import { bundleWorker } from "./bundle";
 import { fetchResult } from "./cfetch";
 import { createWorkerUploadForm } from "./create-worker-upload-form";
+import { logger } from "./logger";
 import { syncAssets } from "./sites";
 import type { Config } from "./config";
 import type { Entry } from "./entry";
@@ -22,12 +23,17 @@ type Props = {
   compatibilityDate: string | undefined;
   compatibilityFlags: string[] | undefined;
   assetPaths: AssetPaths | undefined;
-  triggers: (string | number)[] | undefined;
-  routes: (string | number)[] | undefined;
+  triggers: string[] | undefined;
+  routes: string[] | undefined;
   legacyEnv: boolean | undefined;
-  jsxFactory: undefined | string;
-  jsxFragment: undefined | string;
+  jsxFactory: string | undefined;
+  jsxFragment: string | undefined;
+  tsconfig: string | undefined;
   experimentalPublic: boolean;
+  minify: boolean | undefined;
+  nodeCompat: boolean | undefined;
+  outDir: string | undefined;
+  dryRun: boolean | undefined;
 };
 
 function sleep(ms: number) {
@@ -40,18 +46,28 @@ export default async function publish(props: Props): Promise<void> {
 
   assert(
     props.compatibilityDate || config.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."
+    "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 ?? (config.route ? [config.route] : []) ?? [];
 
-  const deployToWorkersDev = config.workers_dev;
+  // deployToWorkersDev defaults to true only if there aren't any routes defined
+  const deployToWorkersDev = config.workers_dev ?? routes.length === 0;
 
   const jsxFactory = props.jsxFactory || config.jsx_factory;
   const jsxFragment = props.jsxFragment || config.jsx_fragment;
 
+  const minify = props.minify ?? config.minify;
+
+  const nodeCompat = props.nodeCompat ?? config.node_compat;
+  if (nodeCompat) {
+    logger.warn(
+      "Enabling node.js compatibility mode for builtins and globals. This is experimental and has serious tradeoffs. Please see https://github.com/ionic-team/rollup-plugin-node-polyfills/ for more details."
+    );
+  }
+
   const scriptName = props.name;
   assert(
     scriptName,
@@ -63,61 +79,138 @@ export default async function publish(props: Props): Promise<void> {
     "A [site] definition requires a `bucket` field with a path to the site's public directory."
   );
 
-  const destination = await tmp.dir({ unsafeCleanup: true });
-  try {
-    const envName = props.env ?? "production";
+  if (props.outDir) {
+    // we're using a custom output directory,
+    // so let's first ensure it exists
+    mkdirSync(props.outDir, { recursive: true });
+    // add a README
+    const readmePath = path.join(props.outDir, "README.md");
+    writeFileSync(
+      readmePath,
+      `This folder contains the built output assets for the worker "${scriptName}" generated at ${new Date().toISOString()}.`
+    );
+  }
 
-    const { format } = props.entry;
+  const destination = props.outDir ?? (await tmp.dir({ unsafeCleanup: true }));
+  const envName = props.env ?? "production";
 
-    if (props.experimentalPublic && format === "service-worker") {
-      // TODO: check config too
-      throw new Error(
-        "You cannot publish in the service worker format with a public directory."
-      );
-    }
+  const start = Date.now();
+  const notProd = !props.legacyEnv && props.env;
+  const workerName = notProd ? `${scriptName} (${envName})` : scriptName;
+  const workerUrl = notProd
+    ? `/accounts/${accountId}/workers/services/${scriptName}/environments/${envName}`
+    : `/accounts/${accountId}/workers/scripts/${scriptName}`;
 
-    if (config.wasm_modules && format === "modules") {
-      throw new Error(
-        "You cannot configure [wasm_modules] with an ES module worker. Instead, import the .wasm module directly in your code"
-      );
-    }
+  let available_on_subdomain; // we'll set this later
 
-    if (config.text_blobs && format === "modules") {
-      throw new Error(
-        "You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[build.upload.rules]` in your wrangler.toml"
-      );
-    }
+  const { format } = props.entry;
+
+  if (props.experimentalPublic && format === "service-worker") {
+    throw new Error(
+      "You cannot publish in the service-worker format with a public directory."
+    );
+  }
+
+  if (config.wasm_modules && format === "modules") {
+    throw new Error(
+      "You cannot configure [wasm_modules] with an ES module worker. Instead, import the .wasm module directly in your code"
+    );
+  }
+
+  if (config.text_blobs && format === "modules") {
+    throw new Error(
+      "You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[rules]` in your wrangler.toml"
+    );
+  }
 
+  if (config.data_blobs && format === "modules") {
+    throw new Error(
+      "You cannot configure [data_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[rules]` in your wrangler.toml"
+    );
+  }
+  try {
     const { modules, resolvedEntryPointPath, bundleType } = await bundleWorker(
       props.entry,
-      destination.path,
+      typeof destination === "string" ? destination : destination.path,
       {
         serveAssetsFromWorker: props.experimentalPublic,
         jsxFactory,
         jsxFragment,
         rules: props.rules,
+        tsconfig: props.tsconfig ?? config.tsconfig,
+        minify,
+        nodeCompat,
       }
     );
 
+    // 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
-    // get current migration tag
     let migrations;
     if (config.migrations.length > 0) {
-      const scripts = await fetchResult<
-        { id: string; migration_tag: string }[]
-      >(`/accounts/${accountId}/workers/scripts`);
-      const script = scripts.find(({ id }) => id === scriptName);
+      // 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 === script.migration_tag
+          (migration) => migration.tag === scriptMigrationTag
         );
         if (foundIndex === -1) {
-          console.warn(
+          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 = {
@@ -126,15 +219,21 @@ export default async function publish(props: Props): Promise<void> {
             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),
-          };
+          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),
@@ -150,7 +249,8 @@ export default async function publish(props: Props): Promise<void> {
       // concept of service environments for kv namespaces yet).
       scriptName + (!props.legacyEnv && props.env ? `-${props.env}` : ""),
       props.assetPaths,
-      false
+      false,
+      props.dryRun
     );
 
     const bindings: CfWorkerInit["bindings"] = {
@@ -168,6 +268,7 @@ export default async function publish(props: Props): Promise<void> {
             __STATIC_CONTENT_MANIFEST: "__STATIC_CONTENT_MANIFEST",
           }),
       },
+      data_blobs: config.data_blobs,
       durable_objects: config.durable_objects,
       r2_buckets: config.r2_buckets,
       unsafe: config.unsafe?.bindings,
@@ -197,57 +298,68 @@ export default async function publish(props: Props): Promise<void> {
       usage_model: config.usage_model,
     };
 
-    const start = Date.now();
-    const notProd = !props.legacyEnv && props.env;
-    const workerName = notProd ? `${scriptName} (${envName})` : scriptName;
-    const workerUrl = notProd
-      ? `/accounts/${accountId}/workers/services/${scriptName}/environments/${envName}`
-      : `/accounts/${accountId}/workers/scripts/${scriptName}`;
+    if (!props.dryRun) {
+      // Upload the script so it has time to propagate.
+      // We can also now tell whether available_on_subdomain is set
+      available_on_subdomain = (
+        await fetchResult<{ available_on_subdomain: boolean }>(
+          workerUrl,
+          {
+            method: "PUT",
+            body: createWorkerUploadForm(worker),
+          },
+          new URLSearchParams({ include_subdomain_availability: "true" })
+        )
+      ).available_on_subdomain;
+    }
+  } finally {
+    if (typeof destination !== "string") {
+      // this means we're using a temp dir,
+      // so let's clean up before we proceed
+      await destination.cleanup();
+    }
+  }
 
-    // Upload the script so it has time to propagate.
-    const { available_on_subdomain } = await fetchResult(
-      workerUrl,
-      {
-        method: "PUT",
-        body: createWorkerUploadForm(worker),
-      },
-      new URLSearchParams({ available_on_subdomain: "true" })
-    );
+  if (props.dryRun) {
+    logger.log(`--dry-run: exiting now.`);
+    return;
+  }
 
-    const uploadMs = Date.now() - start;
-    const deployments: Promise<string[]>[] = [];
-
-    if (deployToWorkersDev) {
-      // Deploy to a subdomain of `workers.dev`
-      const userSubdomain = await getSubdomain(accountId);
-      const scriptURL =
-        props.legacyEnv || !props.env
-          ? `${scriptName}.${userSubdomain}.workers.dev`
-          : `${envName}.${scriptName}.${userSubdomain}.workers.dev`;
-      if (!available_on_subdomain) {
-        // Enable the `workers.dev` subdomain.
-        deployments.push(
-          fetchResult(`${workerUrl}/subdomain`, {
-            method: "POST",
-            body: JSON.stringify({ enabled: true }),
-            headers: {
-              "Content-Type": "application/json",
-            },
+  const uploadMs = Date.now() - start;
+  const deployments: Promise<string[]>[] = [];
+
+  if (deployToWorkersDev) {
+    // Deploy to a subdomain of `workers.dev`
+    const userSubdomain = await getSubdomain(accountId);
+    const scriptURL =
+      props.legacyEnv || !props.env
+        ? `${scriptName}.${userSubdomain}.workers.dev`
+        : `${envName}.${scriptName}.${userSubdomain}.workers.dev`;
+    if (!available_on_subdomain) {
+      // Enable the `workers.dev` subdomain.
+      deployments.push(
+        fetchResult(`${workerUrl}/subdomain`, {
+          method: "POST",
+          body: JSON.stringify({ enabled: true }),
+          headers: {
+            "Content-Type": "application/json",
+          },
+        })
+          .then(() => [scriptURL])
+          // Add a delay when the subdomain is first created.
+          // 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(async (url) => {
+            await sleep(3000);
+            return url;
           })
-            .then(() => [scriptURL])
-            // Add a delay when the subdomain is first created.
-            // 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(async (url) => {
-              await sleep(3000);
-              return url;
-            })
-        );
-      } else {
-        deployments.push(Promise.resolve([scriptURL]));
-      }
+      );
     } else {
+      deployments.push(Promise.resolve([scriptURL]));
+    }
+  } else {
+    if (available_on_subdomain) {
       // Disable the workers.dev deployment
       await fetchResult(`${workerUrl}/subdomain`, {
         method: "POST",
@@ -257,63 +369,73 @@ export default async function publish(props: Props): Promise<void> {
         },
       });
     }
+  }
 
-    console.log("Uploaded", workerName, formatTime(uploadMs));
+  logger.log("Uploaded", workerName, formatTime(uploadMs));
 
-    // Update routing table for the script.
-    if (routes.length > 0) {
-      deployments.push(
-        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.
-          method: "PUT",
-          body: JSON.stringify(routes.map((pattern) => ({ pattern }))),
-          headers: {
-            "Content-Type": "application/json",
-          },
-        }).then(() => {
-          if (routes.length > 10) {
-            return routes
-              .slice(0, 9)
-              .map(String)
-              .concat([`...and ${routes.length - 10} more routes`]);
-          }
-          return routes.map(String);
-        })
-      );
-    }
+  // Update routing table for the script.
+  if (routes.length > 0) {
+    deployments.push(
+      fetchResult(`${workerUrl}/routes`, {
+        // Note: PUT will delete previous routes on this script.
+        method: "PUT",
+        body: JSON.stringify(
+          routes.map((route) =>
+            typeof route !== "object" ? { pattern: route } : route
+          )
+        ),
+        headers: {
+          "Content-Type": "application/json",
+        },
+      }).then(() => {
+        if (routes.length > 10) {
+          return routes
+            .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`]);
+        }
+        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})`
+        );
+      })
+    );
+  }
 
-    // Configure any schedules for the script.
-    // TODO: rename this to `schedules`?
-    if (triggers && triggers.length) {
-      deployments.push(
-        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.
-          method: "PUT",
-          body: JSON.stringify(triggers.map((cron) => ({ cron }))),
-          headers: {
-            "Content-Type": "application/json",
-          },
-        }).then(() => triggers.map(String))
-      );
-    }
+  // Configure any schedules for the script.
+  // TODO: rename this to `schedules`?
+  if (triggers && triggers.length) {
+    deployments.push(
+      fetchResult(`${workerUrl}/schedules`, {
+        // Note: PUT will override previous schedules on this script.
+        method: "PUT",
+        body: JSON.stringify(triggers.map((cron) => ({ cron }))),
+        headers: {
+          "Content-Type": "application/json",
+        },
+      }).then(() => triggers.map((trigger) => `schedule: ${trigger}`))
+    );
+  }
 
-    const targets = await Promise.all(deployments);
-    const deployMs = Date.now() - start - uploadMs;
+  const targets = await Promise.all(deployments);
+  const deployMs = Date.now() - start - uploadMs;
 
-    if (deployments.length > 0) {
-      console.log("Published", workerName, formatTime(deployMs));
-      for (const target of targets.flat()) {
-        console.log(" ", target);
-      }
-    } else {
-      console.log("No publish targets for", workerName, formatTime(deployMs));
+  if (deployments.length > 0) {
+    logger.log("Published", workerName, formatTime(deployMs));
+    for (const target of targets.flat()) {
+      logger.log(" ", target);
     }
-  } finally {
-    await destination.cleanup();
+  } else {
+    logger.log("No publish targets for", workerName, formatTime(deployMs));
   }
 }