wrangler 2.0.7 → 2.0.8

package/src/config/validation.ts

@@ -94,22 +94,6 @@ export function normalizeAndValidateConfig(
     "boolean"
   );
 
-  validateOptionalProperty(
-    diagnostics,
-    "",
-    "minify",
-    rawConfig.minify,
-    "boolean"
-  );
-
-  validateOptionalProperty(
-    diagnostics,
-    "",
-    "node_compat",
-    rawConfig.node_compat,
-    "boolean"
-  );
-
   // TODO: set the default to false to turn on service environments as the default
   const isLegacyEnv =
     (args as { "legacy-env": boolean | undefined })["legacy-env"] ??
@@ -400,29 +384,38 @@ function normalizeAndValidateMigrations(
     return [];
   } else {
     for (let i = 0; i < rawMigrations.length; i++) {
-      const migration = rawMigrations[i];
+      const { tag, new_classes, renamed_classes, deleted_classes, ...rest } =
+        rawMigrations[i];
+
+      validateAdditionalProperties(
+        diagnostics,
+        "migrations",
+        Object.keys(rest),
+        []
+      );
+
       validateRequiredProperty(
         diagnostics,
         `migrations[${i}]`,
         `tag`,
-        migration.tag,
+        tag,
         "string"
       );
       validateOptionalTypedArray(
         diagnostics,
         `migrations[${i}].new_classes`,
-        migration.new_classes,
+        new_classes,
         "string"
       );
-      if (migration.renamed_classes !== undefined) {
-        if (!Array.isArray(migration.renamed_classes)) {
+      if (renamed_classes !== undefined) {
+        if (!Array.isArray(renamed_classes)) {
           diagnostics.errors.push(
             `Expected "migrations[${i}].renamed_classes" to be an array of "{from: string, to: string}" objects but got ${JSON.stringify(
-              migration.renamed_classes
+              renamed_classes
             )}.`
           );
         } else if (
-          migration.renamed_classes.some(
+          renamed_classes.some(
             (c) =>
               typeof c !== "object" ||
               !isRequiredProperty(c, "from", "string") ||
@@ -431,7 +424,7 @@ function normalizeAndValidateMigrations(
         ) {
           diagnostics.errors.push(
             `Expected "migrations[${i}].renamed_classes" to be an array of "{from: string, to: string}" objects but got ${JSON.stringify(
-              migration.renamed_classes
+              renamed_classes
             )}.`
           );
         }
@@ -439,7 +432,7 @@ function normalizeAndValidateMigrations(
       validateOptionalTypedArray(
         diagnostics,
         `migrations[${i}].deleted_classes`,
-        migration.deleted_classes,
+        deleted_classes,
         "string"
       );
     }
@@ -453,13 +446,32 @@ function normalizeAndValidateMigrations(
         (binding) => !binding.script_name
       );
       if (exportedDurableObjects.length > 0 && rawMigrations.length === 0) {
-        diagnostics.warnings.push(
-          `In wrangler.toml, you have configured [durable_objects] exported by this Worker (${exportedDurableObjects
-            .map((durable) => durable.class_name || "(unnamed)")
-            .join(
+        if (
+          !exportedDurableObjects.some(
+            (exportedDurableObject) =>
+              typeof exportedDurableObject.class_name !== "string"
+          )
+        ) {
+          const durableObjectClassnames = exportedDurableObjects.map(
+            (durable) => durable.class_name
+          );
+
+          diagnostics.warnings.push(
+            `In wrangler.toml, you have configured [durable_objects] exported by this Worker (${durableObjectClassnames.join(
               ", "
-            )}), 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.`
-        );
+            )}), but no [migrations] for them. This may not work as expected until you add a [migrations] section to your wrangler.toml. Add this configuration to your wrangler.toml:
+
+  \`\`\`
+  [[migrations]]
+  tag = "v1" # Should be unique for each entry
+  new_classes = [${durableObjectClassnames
+    .map((name) => `"${name}"`)
+    .join(", ")}]
+  \`\`\`
+
+Refer to https://developers.cloudflare.com/workers/learning/using-durable-objects/#durable-object-migrations-in-wranglertoml for more details.`
+          );
+        }
       }
     }
 
@@ -928,8 +940,22 @@ function normalizeAndValidateEnvironment(
       }
     ),
     zone_id: rawEnv.zone_id,
-    minify: rawEnv.minify,
-    node_compat: rawEnv.node_compat,
+    minify: inheritable(
+      diagnostics,
+      topLevelEnv,
+      rawEnv,
+      "minify",
+      isBoolean,
+      undefined
+    ),
+    node_compat: inheritable(
+      diagnostics,
+      topLevelEnv,
+      rawEnv,
+      "node_compat",
+      isBoolean,
+      undefined
+    ),
   };
 
   return environment;

package/src/dev/dev.tsx

@@ -9,7 +9,6 @@ import { withErrorBoundary, useErrorHandler } from "react-error-boundary";
 import onExit from "signal-exit";
 import tmp from "tmp-promise";
 import { fetch } from "undici";
-import { printBindings } from "../config";
 import { runCustomBuild } from "../entry";
 import { openInspector } from "../inspect";
 import { logger } from "../logger";
@@ -106,8 +105,6 @@ export function DevImplementation(props: DevProps): JSX.Element {
     nodeCompat: props.nodeCompat,
   });
 
-  printBindings(props.bindings);
-
   // only load the UI if we're running in a supported environment
   const { isRawModeSupported } = useStdin();
   return isRawModeSupported ? (

package/src/dialogs.tsx

@@ -1,5 +1,6 @@
 import chalk from "chalk";
 import { Box, Text, useInput, render } from "ink";
+import SelectInput from "ink-select-input";
 import TextInput from "ink-text-input";
 import * as React from "react";
 import { useState } from "react";
@@ -85,3 +86,50 @@ export async function prompt(
     );
   });
 }
+
+type SelectOption = {
+  value: string;
+  label: string;
+};
+
+type SelectProps = {
+  text: string;
+  options: SelectOption[];
+  initialIndex: number;
+  onSelect: (value: string) => void;
+};
+
+function Select(props: SelectProps) {
+  return (
+    <Box flexDirection="column">
+      <Text>{props.text}</Text>
+      <SelectInput
+        initialIndex={props.initialIndex}
+        items={props.options}
+        onSelect={async (selected) => {
+          props.onSelect(selected.value);
+        }}
+      />
+    </Box>
+  );
+}
+
+export function select(
+  text: string,
+  options: SelectOption[],
+  initialIndex: number
+): Promise<string> {
+  return new Promise((resolve) => {
+    const { unmount } = render(
+      <Select
+        text={text}
+        options={options}
+        initialIndex={initialIndex}
+        onSelect={(option: string) => {
+          unmount();
+          resolve(option);
+        }}
+      />
+    );
+  });
+}

package/src/index.tsx

@@ -15,11 +15,11 @@ import { setGlobalDispatcher, ProxyAgent } from "undici";
 import makeCLI from "yargs";
 import { version as wranglerVersion } from "../package.json";
 import { fetchResult } from "./cfetch";
-import { findWranglerToml, readConfig } from "./config";
+import { findWranglerToml, printBindings, readConfig } from "./config";
 import { createWorkerUploadForm } from "./create-worker-upload-form";
 import Dev from "./dev/dev";
 import { getVarsForDev } from "./dev/dev-vars";
-import { confirm, prompt } from "./dialogs";
+import { confirm, prompt, select } from "./dialogs";
 import { getEntry } from "./entry";
 import { DeprecationError } from "./errors";
 import {
@@ -628,21 +628,21 @@ function createCLIParser(argv: string[]) {
         isWritingScripts: boolean,
         isCreatingWranglerToml: boolean,
         packagePath: string,
-        scriptPath: string
+        scriptPath: string,
+        extraToml: TOML.JsonMap
       ) {
         if (isCreatingWranglerToml) {
-          // rewrite wrangler.toml with main = "path/to/script"
+          // rewrite wrangler.toml with main = "path/to/script" and any additional config specified in `extraToml`
           const parsedWranglerToml = parseTOML(
             readFileSync(wranglerTomlDestination)
           );
-          fs.writeFileSync(
-            wranglerTomlDestination,
-            TOML.stringify({
-              name: parsedWranglerToml.name,
-              main: scriptPath,
-              compatibility_date: parsedWranglerToml.compatibility_date,
-            })
-          );
+          const newToml = {
+            name: parsedWranglerToml.name,
+            main: scriptPath,
+            compatibility_date: parsedWranglerToml.compatibility_date,
+            ...extraToml,
+          };
+          fs.writeFileSync(wranglerTomlDestination, TOML.stringify(newToml));
         }
         const isNamedWorker =
           isCreatingWranglerToml && path.dirname(packagePath) !== process.cwd();
@@ -658,7 +658,7 @@ function createCLIParser(argv: string[]) {
                   start: isCreatingWranglerToml
                     ? `wrangler dev`
                     : `wrangler dev ${scriptPath}`,
-                  publish: isCreatingWranglerToml
+                  deploy: isCreatingWranglerToml
                     ? `wrangler publish`
                     : `wrangler publish ${scriptPath}`,
                 },
@@ -673,7 +673,7 @@ function createCLIParser(argv: string[]) {
             }npm start\``
           );
           instructions.push(
-            `To publish your Worker to the Internet, run \`npm run publish\``
+            `To publish your Worker to the Internet, run \`npm run deploy\``
           );
         } else {
           instructions.push(
@@ -689,24 +689,75 @@ function createCLIParser(argv: string[]) {
         }
       }
 
+      async function getNewWorkerType(newWorkerFilename: string) {
+        return select(
+          `Would you like to create a Worker at ${newWorkerFilename}?`,
+          [
+            {
+              value: "none",
+              label: "None",
+            },
+            {
+              value: "fetch",
+              label: "Fetch handler",
+            },
+            {
+              value: "scheduled",
+              label: "Scheduled handler",
+            },
+          ],
+          1
+        ) as Promise<"none" | "fetch" | "scheduled">;
+      }
+
+      function getNewWorkerTemplate(
+        lang: "js" | "ts",
+        workerType: "fetch" | "scheduled"
+      ) {
+        const templates = {
+          "js-fetch": "new-worker.js",
+          "js-scheduled": "new-worker-scheduled.js",
+          "ts-fetch": "new-worker.ts",
+          "ts-scheduled": "new-worker-scheduled.ts",
+        };
+
+        return templates[`${lang}-${workerType}`];
+      }
+
+      function getNewWorkerToml(
+        workerType: "fetch" | "scheduled"
+      ): TOML.JsonMap {
+        if (workerType === "scheduled") {
+          return {
+            triggers: {
+              crons: ["1 * * * *"],
+            },
+          };
+        }
+
+        return {};
+      }
+
       if (isTypescriptProject) {
         if (!fs.existsSync(path.join(creationDirectory, "./src/index.ts"))) {
-          const shouldCreateSource =
-            yesFlag ||
-            (await confirm(
-              `Would you like to create a Worker at ${path.relative(
-                process.cwd(),
-                path.join(creationDirectory, "./src/index.ts")
-              )}?`
-            ));
+          const newWorkerFilename = path.relative(
+            process.cwd(),
+            path.join(creationDirectory, "./src/index.ts")
+          );
+
+          const newWorkerType = yesFlag
+            ? "fetch"
+            : await getNewWorkerType(newWorkerFilename);
+
+          if (newWorkerType !== "none") {
+            const template = getNewWorkerTemplate("ts", newWorkerType);
 
-          if (shouldCreateSource) {
             await mkdir(path.join(creationDirectory, "./src"), {
               recursive: true,
             });
             await writeFile(
               path.join(creationDirectory, "./src/index.ts"),
-              readFileSync(path.join(__dirname, "../templates/new-worker.ts"))
+              readFileSync(path.join(__dirname, `../templates/${template}`))
             );
 
             logger.log(
@@ -720,28 +771,31 @@ function createCLIParser(argv: string[]) {
               shouldWritePackageJsonScripts,
               justCreatedWranglerToml,
               pathToPackageJson,
-              "src/index.ts"
+              "src/index.ts",
+              getNewWorkerToml(newWorkerType)
             );
           }
         }
       } else {
         if (!fs.existsSync(path.join(creationDirectory, "./src/index.js"))) {
-          const shouldCreateSource =
-            yesFlag ||
-            (await confirm(
-              `Would you like to create a Worker at ${path.relative(
-                process.cwd(),
-                path.join(creationDirectory, "./src/index.js")
-              )}?`
-            ));
+          const newWorkerFilename = path.relative(
+            process.cwd(),
+            path.join(creationDirectory, "./src/index.js")
+          );
+
+          const newWorkerType = yesFlag
+            ? "fetch"
+            : await getNewWorkerType(newWorkerFilename);
+
+          if (newWorkerType !== "none") {
+            const template = getNewWorkerTemplate("js", newWorkerType);
 
-          if (shouldCreateSource) {
             await mkdir(path.join(creationDirectory, "./src"), {
               recursive: true,
             });
             await writeFile(
               path.join(creationDirectory, "./src/index.js"),
-              readFileSync(path.join(__dirname, "../templates/new-worker.js"))
+              readFileSync(path.join(__dirname, `../templates/${template}`))
             );
 
             logger.log(
@@ -755,7 +809,8 @@ function createCLIParser(argv: string[]) {
               shouldWritePackageJsonScripts,
               justCreatedWranglerToml,
               pathToPackageJson,
-              "src/index.js"
+              "src/index.js",
+              getNewWorkerToml(newWorkerType)
             );
           }
         }
@@ -1119,6 +1174,70 @@ function createCLIParser(argv: string[]) {
         );
       }
 
+      const bindings = {
+        kv_namespaces: config.kv_namespaces?.map(
+          ({ binding, preview_id, id: _id }) => {
+            // In `dev`, we make folks use a separate kv namespace called
+            // `preview_id` instead of `id` so that they don't
+            // break production data. So here we check that a `preview_id`
+            // has actually been configured.
+            // This whole block of code will be obsoleted in the future
+            // when we have copy-on-write for previews on edge workers.
+            if (!preview_id) {
+              // TODO: This error has to be a _lot_ better, ideally just asking
+              // to create a preview namespace for the user automatically
+              throw new Error(
+                `In development, you should use a separate kv namespace than the one you'd use in production. Please create a new kv namespace with "wrangler kv:namespace create <name> --preview" and add its id as preview_id to the kv_namespace "${binding}" in your wrangler.toml`
+              ); // Ugh, I really don't like this message very much
+            }
+            return {
+              binding,
+              id: preview_id,
+            };
+          }
+        ),
+        // Use a copy of combinedVars since we're modifying it later
+        vars: getVarsForDev(config),
+        wasm_modules: config.wasm_modules,
+        text_blobs: config.text_blobs,
+        data_blobs: config.data_blobs,
+        durable_objects: config.durable_objects,
+        r2_buckets: config.r2_buckets?.map(
+          ({ binding, preview_bucket_name, bucket_name: _bucket_name }) => {
+            // same idea as kv namespace preview id,
+            // same copy-on-write TODO
+            if (!preview_bucket_name) {
+              throw new Error(
+                `In development, you should use a separate r2 bucket than the one you'd use in production. Please create a new r2 bucket with "wrangler r2 bucket create <name>" and add its name as preview_bucket_name to the r2_buckets "${binding}" in your wrangler.toml`
+              );
+            }
+            return {
+              binding,
+              bucket_name: preview_bucket_name,
+            };
+          }
+        ),
+        services: config.services,
+        unsafe: config.unsafe?.bindings,
+      };
+
+      // mask anything that was overridden in .dev.vars
+      // so that we don't log potential secrets into the terminal
+      const maskedVars = { ...bindings.vars };
+      for (const key of Object.keys(maskedVars)) {
+        if (maskedVars[key] !== config.vars[key]) {
+          // This means it was overridden in .dev.vars
+          // so let's mask it
+          maskedVars[key] = "(hidden)";
+        }
+      }
+
+      // now log all available bindings into the terminal
+      printBindings({
+        ...bindings,
+        vars: maskedVars,
+      });
+
       const { waitUntilExit } = render(
         <Dev
           name={getScriptName(args, config)}
@@ -1164,51 +1283,7 @@ function createCLIParser(argv: string[]) {
             args["compatibility-flags"] || config.compatibility_flags
           }
           usageModel={config.usage_model}
-          bindings={{
-            kv_namespaces: config.kv_namespaces?.map(
-              ({ binding, preview_id, id: _id }) => {
-                // In `dev`, we make folks use a separate kv namespace called
-                // `preview_id` instead of `id` so that they don't
-                // break production data. So here we check that a `preview_id`
-                // has actually been configured.
-                // This whole block of code will be obsoleted in the future
-                // when we have copy-on-write for previews on edge workers.
-                if (!preview_id) {
-                  // TODO: This error has to be a _lot_ better, ideally just asking
-                  // to create a preview namespace for the user automatically
-                  throw new Error(
-                    `In development, you should use a separate kv namespace than the one you'd use in production. Please create a new kv namespace with "wrangler kv:namespace create <name> --preview" and add its id as preview_id to the kv_namespace "${binding}" in your wrangler.toml`
-                  ); // Ugh, I really don't like this message very much
-                }
-                return {
-                  binding,
-                  id: preview_id,
-                };
-              }
-            ),
-            vars: getVarsForDev(config),
-            wasm_modules: config.wasm_modules,
-            text_blobs: config.text_blobs,
-            data_blobs: config.data_blobs,
-            durable_objects: config.durable_objects,
-            r2_buckets: config.r2_buckets?.map(
-              ({ binding, preview_bucket_name, bucket_name: _bucket_name }) => {
-                // same idea as kv namespace preview id,
-                // same copy-on-write TODO
-                if (!preview_bucket_name) {
-                  throw new Error(
-                    `In development, you should use a separate r2 bucket than the one you'd use in production. Please create a new r2 bucket with "wrangler r2 bucket create <name>" and add its name as preview_bucket_name to the r2_buckets "${binding}" in your wrangler.toml`
-                  );
-                }
-                return {
-                  binding,
-                  bucket_name: preview_bucket_name,
-                };
-              }
-            ),
-            services: config.services,
-            unsafe: config.unsafe?.bindings,
-          }}
+          bindings={bindings}
           crons={config.triggers.crons}
         />
       );
@@ -2752,14 +2827,14 @@ export async function main(argv: string[]): Promise<void> {
       await createCLIParser([...argv, "--help"]).parse();
     } else if (e instanceof ParseError) {
       e.notes.push({
-        text: "\nIf you think this is a bug, please open an issue at: https://github.com/cloudflare/wrangler2/issues/new",
+        text: "\nIf you think this is a bug, please open an issue at: https://github.com/cloudflare/wrangler2/issues/new/choose",
       });
-      logger.error(formatMessage(e));
+      logger.log(formatMessage(e));
     } else {
       logger.error(e instanceof Error ? e.message : e);
       logger.log(
         `${fgGreenColor}%s${resetColor}`,
-        "If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        "If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
       );
     }
     throw e;

package/src/package-manager.ts

@@ -5,15 +5,20 @@ import { logger } from "./logger";
 
 export interface PackageManager {
   cwd: string;
-  type: "npm" | "yarn";
+  type: "npm" | "yarn" | "pnpm";
   addDevDeps(...packages: string[]): Promise<void>;
   install(): Promise<void>;
 }
 
 export async function getPackageManager(cwd: string): Promise<PackageManager> {
-  const [hasYarn, hasNpm] = await Promise.all([supportsYarn(), supportsNpm()]);
+  const [hasYarn, hasNpm, hasPnpm] = await Promise.all([
+    supportsYarn(),
+    supportsNpm(),
+    supportsPnpm(),
+  ]);
   const hasYarnLock = existsSync(join(cwd, "yarn.lock"));
   const hasNpmLock = existsSync(join(cwd, "package-lock.json"));
+  const hasPnpmLock = existsSync(join(cwd, "pnpm-lock.yaml"));
 
   if (hasNpmLock) {
     if (hasNpm) {
@@ -28,6 +33,18 @@ export async function getPackageManager(cwd: string): Promise<PackageManager> {
       );
       return { ...YarnPackageManager, cwd };
     }
+  } else if (hasPnpmLock) {
+    if (hasPnpm) {
+      logger.log(
+        "Using pnpm as package manager, as there is already a pnpm-lock.yaml file."
+      );
+      return { ...PnpmPackageManager, cwd };
+    } else {
+      logger.warn(
+        "There is already a pnpm-lock.yaml file but could not find pnpm on the PATH."
+      );
+      // will simply fallback to the first found of [npm, yaml, pnpm] in the next if round.
+    }
   } else if (hasYarnLock) {
     if (hasYarn) {
       logger.log(
@@ -49,9 +66,12 @@ export async function getPackageManager(cwd: string): Promise<PackageManager> {
   } else if (hasYarn) {
     logger.log("Using yarn as package manager.");
     return { ...YarnPackageManager, cwd };
+  } else if (hasPnpm) {
+    logger.log("Using pnpm as package manager.");
+    return { ...PnpmPackageManager, cwd };
   } else {
     throw new Error(
-      "Unable to find a package manager. Supported managers are: npm and yarn."
+      "Unable to find a package manager. Supported managers are: npm, yarn, and pnpm."
     );
   }
 }
@@ -86,6 +106,29 @@ const NpmPackageManager: PackageManager = {
   },
 };
 
+/**
+ * Manage packages using pnpm
+ */
+const PnpmPackageManager: PackageManager = {
+  cwd: process.cwd(),
+  type: "pnpm",
+  /** Add and install a new devDependency into the local package.json. */
+  async addDevDeps(...packages: string[]): Promise<void> {
+    await execa("pnpm", ["install", ...packages, "--save-dev"], {
+      stdio: "inherit",
+      cwd: this.cwd,
+    });
+  },
+
+  /** Install all the dependencies in the local package.json. */
+  async install(): Promise<void> {
+    await execa("pnpm", ["install"], {
+      stdio: "inherit",
+      cwd: this.cwd,
+    });
+  },
+};
+
 /**
  * Manage packages using yarn
  */
@@ -125,3 +168,7 @@ function supportsYarn(): Promise<boolean> {
 function supportsNpm(): Promise<boolean> {
   return supports("npm");
 }
+
+function supportsPnpm(): Promise<boolean> {
+  return supports("pnpm");
+}

package/src/pages.tsx

@@ -1066,6 +1066,7 @@ const createDeployment: CommandModule<
       "_headers",
       ".DS_Store",
       "node_modules",
+      ".git",
     ];
 
     const walk = async (
@@ -1522,6 +1523,9 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
           } else {
             logger.log("No functions. Shimming...");
             miniflareArgs = {
+              // cfFetch sets the `cf` object that a function could expect
+              // If there are no functions, there's no reason to set this up (and not make that network call)
+              cfFetch: false,
               // TODO: The fact that these request/response hacks are necessary is ridiculous.
               // We need to eliminate them from env.ASSETS.fetch (not sure if just local or prod as well)
               script: `