wrangler 2.0.7 → 2.0.11

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 {
@@ -66,6 +66,7 @@ import {
   requireAuth,
 } from "./user";
 import { whoami } from "./whoami";
+import { getZoneIdFromHost, getZoneForRoute } from "./zones";
 
 import type { Config } from "./config";
 import type { TailCLIFilters } from "./tail";
@@ -444,7 +445,10 @@ function createCLIParser(argv: string[]) {
           yesFlag ||
           (await confirm("Would you like to use git to manage this Worker?"));
         if (shouldInitGit) {
-          await execa("git", ["init", "--initial-branch=main"], {
+          await execa("git", ["init"], {
+            cwd: creationDirectory,
+          });
+          await execa("git", ["branch", "-m", "main"], {
             cwd: creationDirectory,
           });
           await writeFile(
@@ -628,21 +632,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 +662,7 @@ function createCLIParser(argv: string[]) {
                   start: isCreatingWranglerToml
                     ? `wrangler dev`
                     : `wrangler dev ${scriptPath}`,
-                  publish: isCreatingWranglerToml
+                  deploy: isCreatingWranglerToml
                     ? `wrangler publish`
                     : `wrangler publish ${scriptPath}`,
                 },
@@ -673,7 +677,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 +693,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 +775,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 +813,8 @@ function createCLIParser(argv: string[]) {
               shouldWritePackageJsonScripts,
               justCreatedWranglerToml,
               pathToPackageJson,
-              "src/index.js"
+              "src/index.js",
+              getNewWorkerToml(newWorkerType)
             );
           }
         }
@@ -1024,92 +1083,25 @@ function createCLIParser(argv: string[]) {
         );
       }
 
-      const accountId = !args.local ? await requireAuth(config) : undefined;
-
       // TODO: if worker_dev = false and no routes, then error (only for dev)
 
-      /**
-       * Given something that resembles a URL,
-       * try to extract a host from it
-       */
-      function getHost(urlLike: string): string | undefined {
-        // strip leading * / *.
-        urlLike = urlLike.replace(/^\*(\.)?/g, "");
-
-        if (
-          !(urlLike.startsWith("http://") || urlLike.startsWith("https://"))
-        ) {
-          urlLike = "http://" + urlLike;
-        }
-        return new URL(urlLike).host;
-      }
-
-      /**
-       * Given something that resembles a host,
-       * try to infer a zone id from it
-       */
-      async function getZoneId(host: string): Promise<string | undefined> {
-        const zones = await fetchResult<{ id: string }[]>(
-          `/zones`,
-          {},
-          new URLSearchParams({ name: host })
-        );
-        return zones[0]?.id;
-      }
-
-      // When we're given a host (in one of the above ways), we do 2 things:
-      // - We try to extract a host from it
-      // - We try to get a zone id from the host
-      //
-      // So it turns out it's particularly hard to get a 'valid' domain
-      // from a string, so we don't even try to validate TLDs, etc.
-      // Once we get something that looks like w.x.y.z-ish, we then try to
-      // get a zone id for it, by lopping off subdomains until we get a hit
-      // from the API. That's it!
-
-      let zone: { host: string; id: string } | undefined;
+      // Compute zone info from the `host` and `route` args and config;
+      let host = args.host || config.dev.host;
+      let zoneId: string | undefined;
 
       if (!args.local) {
-        const hostLike =
-          args.host ||
-          config.dev.host ||
-          (args.routes && args.routes[0]) ||
-          config.route ||
-          (config.routes && config.routes[0]);
-
-        let zoneId: string | undefined =
-          typeof hostLike === "object" && "zone_id" in hostLike
-            ? hostLike.zone_id
-            : undefined;
-
-        const host =
-          typeof hostLike === "string"
-            ? getHost(hostLike)
-            : typeof hostLike === "object"
-            ? "zone_name" in hostLike
-              ? getHost(hostLike.zone_name)
-              : getHost(hostLike.pattern)
-            : undefined;
-
-        const hostPieces =
-          typeof host === "string" ? host.split(".") : undefined;
-
-        while (!zoneId && hostPieces && hostPieces.length > 1) {
-          zoneId = await getZoneId(hostPieces.join("."));
-          hostPieces.shift();
+        if (host) {
+          zoneId = await getZoneIdFromHost(host);
         }
-
-        if (host && !zoneId) {
-          throw new Error(`Could not find zone for ${hostLike}`);
+        const routes = args.routes || config.route || config.routes;
+        if (!zoneId && routes) {
+          const firstRoute = Array.isArray(routes) ? routes[0] : routes;
+          const zone = await getZoneForRoute(firstRoute);
+          if (zone) {
+            zoneId = zone.id;
+            host = zone.host;
+          }
         }
-
-        zone =
-          typeof zoneId === "string" && typeof host === "string"
-            ? {
-                host,
-                id: zoneId,
-              }
-            : undefined;
       }
 
       const nodeCompat = args.nodeCompat ?? config.node_compat;
@@ -1119,12 +1111,77 @@ 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)}
           entry={entry}
           env={args.env}
-          zone={zone}
+          zone={zoneId}
+          host={host}
           rules={getRules(config)}
           legacyEnv={isLegacyEnv(config)}
           minify={args.minify ?? config.minify}
@@ -1139,7 +1196,7 @@ function createCLIParser(argv: string[]) {
           enableLocalPersistence={
             args["experimental-enable-local-persistence"] || false
           }
-          accountId={accountId}
+          accountId={config.account_id}
           assetPaths={getAssetPaths(
             config,
             args.site,
@@ -1164,51 +1221,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}
         />
       );
@@ -1597,6 +1610,7 @@ function createCLIParser(argv: string[]) {
           rules={getRules(config)}
           env={args.env}
           zone={undefined}
+          host={undefined}
           legacyEnv={isLegacyEnv(config)}
           build={config.build || {}}
           minify={undefined}
@@ -2752,14 +2766,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");
+}