wrangler 0.0.0-e3cab74 → 0.0.0-e3e3243

package/src/__tests__/r2.test.ts

@@ -90,7 +90,7 @@ describe("wrangler", () => {
           await expect(
             runWrangler("r2 bucket create abc def ghi")
           ).rejects.toThrowErrorMatchingInlineSnapshot(
-            `"Unexpected additional positional arguments \\"def ghi\\"."`
+            `"Unknown arguments: def, ghi"`
           );
           expect(std.out).toMatchInlineSnapshot(`""`);
           expect(std.err).toMatchInlineSnapshot(`
@@ -107,7 +107,7 @@ describe("wrangler", () => {
               -v, --version     Show version number  [boolean]
                   --legacy-env  Use legacy environments  [boolean]
 
-            Unexpected additional positional arguments \\"def ghi\\"."
+            Unknown arguments: def, ghi"
           `);
         });
 
@@ -166,7 +166,7 @@ describe("wrangler", () => {
           await expect(
             runWrangler("r2 bucket delete abc def ghi")
           ).rejects.toThrowErrorMatchingInlineSnapshot(
-            `"Unexpected additional positional arguments \\"def ghi\\"."`
+            `"Unknown arguments: def, ghi"`
           );
           expect(std.out).toMatchInlineSnapshot(`""`);
           expect(std.err).toMatchInlineSnapshot(`
@@ -183,7 +183,7 @@ describe("wrangler", () => {
               -v, --version     Show version number  [boolean]
                   --legacy-env  Use legacy environments  [boolean]
 
-            Unexpected additional positional arguments \\"def ghi\\"."
+            Unknown arguments: def, ghi"
           `);
         });
 

package/src/__tests__/route.test.ts

@@ -0,0 +1,45 @@
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+
+describe("wrangler route", () => {
+  mockConsoleMethods();
+  runInTempDir();
+
+  it("shows a deprecation notice when `wrangler route` is run", async () => {
+    await expect(runWrangler("route")).rejects
+      .toThrowErrorMatchingInlineSnapshot(`
+            "DEPRECATION WARNING:
+            \`wrangler route\` has been deprecated.
+            Please use wrangler.toml and/or \`wrangler publish --routes\` to modify routes"
+          `);
+  });
+
+  it("shows a deprecation notice when `wrangler route delete` is run", async () => {
+    await expect(runWrangler("route delete")).rejects
+      .toThrowErrorMatchingInlineSnapshot(`
+            "DEPRECATION WARNING:
+            \`wrangler route delete\` has been deprecated.
+            Remove the unwanted route(s) from wrangler.toml and run \`wrangler publish\` to remove your worker from those routes."
+          `);
+  });
+
+  it("shows a deprecation notice when `wrangler route delete <id>` is run", async () => {
+    await expect(runWrangler("route delete some-zone-id")).rejects
+      .toThrowErrorMatchingInlineSnapshot(`
+            "DEPRECATION WARNING:
+            \`wrangler route delete\` has been deprecated.
+            Remove the unwanted route(s) from wrangler.toml and run \`wrangler publish\` to remove your worker from those routes."
+          `);
+  });
+
+  it("shows a deprecation notice when `wrangler route list` is run", async () => {
+    await expect(runWrangler("route list")).rejects
+      .toThrowErrorMatchingInlineSnapshot(`
+            "DEPRECATION WARNING:
+            \`wrangler route list\` has been deprecated.
+            Refer to wrangler.toml for a list of routes the worker will be deployed to upon publishing.
+            Refer to the Cloudflare Dashboard to see the routes this worker is currently running on."
+          `);
+  });
+});

package/src/__tests__/secret.test.ts

@@ -1,7 +1,11 @@
+import * as fs from "node:fs";
+import * as TOML from "@iarna/toml";
+import fetchMock from "jest-fetch-mock";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
 import { mockConfirm, mockPrompt } from "./helpers/mock-dialogs";
+import { useMockStdin } from "./helpers/mock-stdin";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 
@@ -44,84 +48,181 @@ describe("wrangler secret", () => {
       );
     }
 
-    it("should create a secret", async () => {
-      mockPrompt({
-        text: "Enter a secret value:",
-        type: "password",
-        result: "the-secret",
+    describe("interactive", () => {
+      useMockStdin({ isTTY: true });
+
+      it("should create a secret", async () => {
+        mockPrompt({
+          text: "Enter a secret value:",
+          type: "password",
+          result: "the-secret",
+        });
+
+        mockPutRequest({ name: "the-key", text: "the-secret" });
+        await runWrangler("secret put the-key --name script-name");
+
+        expect(std.out).toMatchInlineSnapshot(`
+                  "🌀 Creating the secret for script script-name
+                  ✨ Success! Uploaded secret the-key"
+              `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
       });
 
-      mockPutRequest({ name: "the-secret-name", text: "the-secret" });
-      await runWrangler("secret put the-key --name script-name");
+      it("should create a secret: legacy envs", async () => {
+        mockPrompt({
+          text: "Enter a secret value:",
+          type: "password",
+          result: "the-secret",
+        });
 
-      expect(std.out).toMatchInlineSnapshot(`
-        "🌀 Creating the secret for script script-name
-        ✨ Success! Uploaded secret the-key"
-      `);
-      expect(std.err).toMatchInlineSnapshot(`""`);
-    });
+        mockPutRequest(
+          { name: "the-key", text: "the-secret" },
+          "some-env",
+          true
+        );
+        await runWrangler(
+          "secret put the-key --name script-name --env some-env --legacy-env"
+        );
 
-    it("should create a secret: legacy envs", async () => {
-      mockPrompt({
-        text: "Enter a secret value:",
-        type: "password",
-        result: "the-secret",
+        expect(std.out).toMatchInlineSnapshot(`
+                  "🌀 Creating the secret for script script-name-some-env
+                  ✨ Success! Uploaded secret the-key"
+              `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
       });
 
-      mockPutRequest(
-        { name: "the-secret-name", text: "the-secret" },
-        "some-env",
-        true
-      );
-      await runWrangler(
-        "secret put the-key --name script-name --env some-env --legacy-env"
-      );
+      it("should create a secret: service envs", async () => {
+        mockPrompt({
+          text: "Enter a secret value:",
+          type: "password",
+          result: "the-secret",
+        });
 
-      expect(std.out).toMatchInlineSnapshot(`
-        "🌀 Creating the secret for script script-name-some-env
-        ✨ Success! Uploaded secret the-key"
-      `);
-      expect(std.err).toMatchInlineSnapshot(`""`);
-    });
+        mockPutRequest(
+          { name: "the-key", text: "the-secret" },
+          "some-env",
+          false
+        );
+        await runWrangler(
+          "secret put the-key --name script-name --env some-env --legacy-env false"
+        );
 
-    it("should create a secret: service envs", async () => {
-      mockPrompt({
-        text: "Enter a secret value:",
-        type: "password",
-        result: "the-secret",
+        expect(std.out).toMatchInlineSnapshot(`
+                  "🌀 Creating the secret for script script-name (some-env)
+                  ✨ Success! Uploaded secret the-key"
+              `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
       });
 
-      mockPutRequest(
-        { name: "the-secret-name", text: "the-secret" },
-        "some-env",
-        false
-      );
-      await runWrangler(
-        "secret put the-key --name script-name --env some-env --legacy-env false"
-      );
+      it("should error without a script name", async () => {
+        let error: Error | undefined;
+        try {
+          await runWrangler("secret put the-key");
+        } catch (e) {
+          error = e as Error;
+        }
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
+          "Missing script name
 
-      expect(std.out).toMatchInlineSnapshot(`
-        "🌀 Creating the secret for script script-name (some-env)
-        ✨ Success! Uploaded secret the-key"
-      `);
-      expect(std.err).toMatchInlineSnapshot(`""`);
+          %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        `);
+        expect(error).toMatchInlineSnapshot(`[Error: Missing script name]`);
+      });
     });
 
-    it("should error without a script name", async () => {
-      let error: Error | undefined;
-      try {
-        await runWrangler("secret put the-key");
-      } catch (e) {
-        error = e as Error;
-      }
-      expect(std.out).toMatchInlineSnapshot(`""`);
-      expect(std.err).toMatchInlineSnapshot(`
-        "Missing script name
+    describe("non-interactive", () => {
+      const mockStdIn = useMockStdin({ isTTY: false });
 
-        %s
-        If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
-      `);
-      expect(error).toMatchInlineSnapshot(`[Error: Missing script name]`);
+      it("should create a secret, from piped input", async () => {
+        mockPutRequest({ name: "the-key", text: "the-secret" });
+        // Pipe the secret in as three chunks to test that we reconstitute it correctly.
+        mockStdIn.send("the", "-", "secret");
+        await runWrangler("secret put the-key --name script-name");
+
+        expect(std.out).toMatchInlineSnapshot(`
+          "🌀 Creating the secret for script script-name
+          ✨ Success! Uploaded secret the-key"
+        `);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should error if the piped input fails", async () => {
+        mockPutRequest({ name: "the-key", text: "the-secret" });
+        mockStdIn.throwError(new Error("Error in stdin stream"));
+        await expect(
+          runWrangler("secret put the-key --name script-name")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(`"Error in stdin stream"`);
+
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
+
+      describe("with accountId", () => {
+        mockAccountId({ accountId: null });
+
+        it("should error if a user has no account", async () => {
+          await expect(
+            runWrangler("secret put the-key --name script-name")
+          ).rejects.toThrowErrorMatchingInlineSnapshot(
+            `"No account id found, quitting..."`
+          );
+        });
+
+        it("should use the account from wrangler.toml", async () => {
+          fs.writeFileSync(
+            "wrangler.toml",
+            TOML.stringify({
+              account_id: "some-account-id",
+            }),
+            "utf-8"
+          );
+          mockStdIn.send("the-secret");
+          mockPutRequest({ name: "the-key", text: "the-secret" });
+          await runWrangler("secret put the-key --name script-name");
+          expect(std.out).toMatchInlineSnapshot(`
+            "🌀 Creating the secret for script script-name
+            ✨ Success! Uploaded secret the-key"
+          `);
+          expect(std.warn).toMatchInlineSnapshot(`""`);
+          expect(std.err).toMatchInlineSnapshot(`""`);
+        });
+
+        it("should error if a user has multiple accounts, and has not specified an account in wrangler.toml", async () => {
+          // This is a mock response for the request to the CF API memberships of the current user.
+          fetchMock.doMockOnce(async () => {
+            return {
+              body: JSON.stringify({
+                success: true,
+                result: [
+                  {
+                    id: "1",
+                    account: { id: "account-id-1", name: "account-name-1" },
+                  },
+                  {
+                    id: "2",
+                    account: { id: "account-id-2", name: "account-name-2" },
+                  },
+                  {
+                    id: "3",
+                    account: { id: "account-id-3", name: "account-name-3" },
+                  },
+                ],
+              }),
+            };
+          });
+          await expect(runWrangler("secret put the-key --name script-name"))
+            .rejects.toThrowErrorMatchingInlineSnapshot(`
+                  "More than one account available but unable to select one in non-interactive mode.
+                  Please set the appropriate \`account_id\` in your \`wrangler.toml\` file.
+                  Available accounts are (\\"<name>\\" - \\"<id>\\"):
+                    \\"account-name-1\\" - \\"account-id-1\\")
+                    \\"account-name-2\\" - \\"account-id-2\\")
+                    \\"account-name-3\\" - \\"account-id-3\\")"
+                `);
+        });
+      });
     });
   });
 
@@ -223,8 +324,7 @@ describe("wrangler secret", () => {
       expect(std.err).toMatchInlineSnapshot(`
         "Missing script name
 
-        %s
-        If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
       `);
       expect(error).toMatchInlineSnapshot(`[Error: Missing script name]`);
     });
@@ -317,8 +417,7 @@ describe("wrangler secret", () => {
       expect(std.err).toMatchInlineSnapshot(`
         "Missing script name
 
-        %s
-        If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
       `);
       expect(error).toMatchInlineSnapshot(`[Error: Missing script name]`);
     });

package/src/__tests__/tail.test.ts

@@ -134,7 +134,7 @@ describe("tail", () => {
 
     it("sends header filters without a query", async () => {
       const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker --header X-CUSTOM-HEADER ");
+      await runWrangler("tail test-worker --header X-CUSTOM-HEADER");
       await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
         { header: { key: "X-CUSTOM-HEADER" } },
       ]);
@@ -142,9 +142,7 @@ describe("tail", () => {
 
     it("sends header filters with a query", async () => {
       const api = mockWebsocketAPIs();
-      await runWrangler(
-        "tail test-worker --header X-CUSTOM-HEADER:some-value "
-      );
+      await runWrangler("tail test-worker --header X-CUSTOM-HEADER:some-value");
       await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
         { header: { key: "X-CUSTOM-HEADER", query: "some-value" } },
       ]);

package/src/__tests__/whoami.test.tsx

@@ -1,30 +1,34 @@
 import { render } from "ink-testing-library";
 import React from "react";
-import { initialise } from "../user";
+import { reinitialiseAuthTokens, writeAuthConfigFile } from "../user";
 import { getUserInfo, WhoAmI } from "../whoami";
 import { setMockResponse } from "./helpers/mock-cfetch";
-import { writeUserConfig } from "./helpers/mock-user";
+import { mockConsoleMethods } from "./helpers/mock-console";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import type { UserInfo } from "../whoami";
 
 describe("getUserInfo()", () => {
   runInTempDir({ homedir: "./home" });
+  const std = mockConsoleMethods();
 
   it("should return undefined if there is no config file", async () => {
-    await initialise();
     const userInfo = await getUserInfo();
     expect(userInfo).toBeUndefined();
   });
 
   it("should return undefined if there is an empty config file", async () => {
-    writeUserConfig();
-    await initialise();
+    writeAuthConfigFile({});
+    // Now that we have changed the auth tokens in the wrangler.toml we must reinitialize the user auth state.
+    reinitialiseAuthTokens();
     const userInfo = await getUserInfo();
     expect(userInfo).toBeUndefined();
   });
 
   it("should return the user's email and accounts if authenticated via config token", async () => {
-    writeUserConfig("some-oauth-token");
+    writeAuthConfigFile({ oauth_token: "some-oauth-token" });
+    // Now that we have changed the auth tokens in the wrangler.toml we must reinitialize the user auth state.
+    reinitialiseAuthTokens();
+
     setMockResponse("/user", () => {
       return { email: "user@example.com" };
     });
@@ -36,7 +40,6 @@ describe("getUserInfo()", () => {
       ];
     });
 
-    await initialise();
     const userInfo = await getUserInfo();
 
     expect(userInfo).toEqual({
@@ -50,6 +53,17 @@ describe("getUserInfo()", () => {
       ],
     });
   });
+
+  it("should display a warning message if the config file contains a legacy api_token field", async () => {
+    writeAuthConfigFile({ api_token: "API_TOKEN" });
+    await reinitialiseAuthTokens();
+    await getUserInfo();
+    expect(std.warn).toMatchInlineSnapshot(`
+      "It looks like you have used Wrangler 1's \`config\` command to login with an API token.
+      This is no longer supported in the current version of Wrangler.
+      If you wish to authenticate via an API token then please set the \`CLOUDFLARE_API_TOKEN\` environment variable."
+    `);
+  });
 });
 
 describe("WhoAmI component", () => {

package/src/bundle.ts

@@ -2,10 +2,10 @@ import assert from "node:assert";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as esbuild from "esbuild";
-import makeModuleCollector from "./module-collection";
-import type { CfModule, CfScriptFormat } from "./api/worker";
+import createModuleCollector from "./module-collection";
 import type { Config } from "./config";
 import type { Entry } from "./entry";
+import type { CfModule } from "./worker";
 
 type BundleResult = {
   modules: CfModule[];
@@ -24,20 +24,36 @@ export async function bundleWorker(
     serveAssetsFromWorker: boolean;
     jsxFactory: string | undefined;
     jsxFragment: string | undefined;
-    format: CfScriptFormat;
     rules: Config["rules"];
     watch?: esbuild.WatchMode;
+    tsconfig: string | undefined;
   }
 ): Promise<BundleResult> {
   const {
     serveAssetsFromWorker,
     jsxFactory,
     jsxFragment,
-    format,
     rules,
     watch,
+    tsconfig,
   } = options;
-  const moduleCollector = makeModuleCollector({ format, rules });
+  const entryDirectory = path.dirname(entry.file);
+  const moduleCollector = createModuleCollector({
+    wrangler1xlegacyModuleReferences: {
+      rootDirectory: entryDirectory,
+      fileNames: new Set(
+        fs
+          .readdirSync(entryDirectory, { withFileTypes: true })
+          .filter(
+            (dirEntry) =>
+              dirEntry.isFile() && dirEntry.name !== path.basename(entry.file)
+          )
+          .map((dirEnt) => dirEnt.name)
+      ),
+    },
+    format: entry.format,
+    rules,
+  });
   const result = await esbuild.build({
     ...getEntryPoint(entry.file, serveAssetsFromWorker),
     bundle: true,
@@ -48,6 +64,11 @@ export async function bundleWorker(
     sourcemap: true,
     metafile: true,
     conditions: ["worker", "browser"],
+    ...(process.env.NODE_ENV && {
+      define: {
+        "process.env.NODE_ENV": `"${process.env.NODE_ENV}"`,
+      },
+    }),
     loader: {
       ".js": "jsx",
       ".mjs": "jsx",
@@ -56,6 +77,7 @@ export async function bundleWorker(
     plugins: [moduleCollector.plugin],
     ...(jsxFactory && { jsxFactory }),
     ...(jsxFragment && { jsxFragment }),
+    ...(tsconfig && { tsconfig }),
     watch,
   });
 

package/src/cfetch/internal.ts

@@ -1,6 +1,7 @@
-import { fetch } from "undici";
+import { fetch, Headers } from "undici";
 import { getEnvironmentVariableFactory } from "../environment-variables";
 import { ParseError, parseJSON } from "../parse";
+import { reportError } from "../reporting";
 import { getAPIToken, loginOrRefreshIfRequired } from "../user";
 import type { URLSearchParams } from "node:url";
 import type { RequestInit, HeadersInit } from "undici";
@@ -47,6 +48,7 @@ export async function fetchInternal<ResponseType>(
   try {
     return parseJSON(jsonText) as ResponseType;
   } catch (err) {
+    await reportError(err as Error);
     throw new ParseError({
       text: "Received a malformed response from the API",
       notes: [
@@ -72,7 +74,11 @@ function truncate(text: string, maxLength: number): string {
 function cloneHeaders(
   headers: HeadersInit | undefined
 ): Record<string, string> {
-  return { ...headers };
+  return headers instanceof Headers
+    ? Object.fromEntries(headers.entries())
+    : Array.isArray(headers)
+    ? Object.fromEntries(headers)
+    : { ...headers };
 }
 
 async function requireLoggedIn(): Promise<void> {
@@ -83,11 +89,11 @@ async function requireLoggedIn(): Promise<void> {
 }
 
 function requireApiToken(): string {
-  const apiToken = getAPIToken();
-  if (!apiToken) {
+  const authToken = getAPIToken();
+  if (!authToken) {
     throw new Error("No API token found.");
   }
-  return apiToken;
+  return authToken;
 }
 
 function addAuthorizationHeader(

package/src/config/README.md

@@ -25,24 +25,23 @@ This includes the `EnvironmentInheritable` and `EnvironmentNonInheritable` field
 ### Config
 
 The "non-overridable" types are defined in the [`ConfigFields`](./config.ts) type.
-Notably this also contains a property called `env` which is the container for the named environment configuration.
-
 The `Config` type is the overall configuration, which consists of the `ConfigFields` and also an `Environment`.
-In this case the `Environment`, here, corresponds to the top level environment.
+In this case the `Environment`, here, corresponds to the "currently active" environment. This is specified by the `--env` command line argument.
+If there is no argument passed then the currently active environment is the "top-level" environment.
 The fields in `Config` and `Environment` are not generally optional and so you can expect they have been filled with suitable inherited or default values.
 These types should be used when you are working with fields that should be passed to commands.
 
 ### RawConfig
 
 The `RawConfig` type is a version of `Config`, where all the fields are optional.
-The `RawConfig` type also includes `DeprecatedConfigFields` and extends and contains the `RawEnvironment` type,
-which is a version of `Environment` where all the fields are optional.
+The `RawConfig` type includes `DeprecatedConfigFields` and `EnvironmentMap`.
+It also extends the `RawEnvironment` type, which is a version of `Environment` where all the fields are optional.
 These optional fields map to the actual fields found in the `wrangler.toml`.
 These types should be used when you are working with raw configuration that is read or will be written to a `wrangler.toml`.
 
 ## Validation
 
-Validation is triggered by passing a `RawConfig` object to the `normalizeAndValidateConfig()` function.
+Validation is triggered by passing a `RawConfig` object, and the active environment name, to the `normalizeAndValidateConfig()` function.
 This function will return:
 
 - a `Config` object, where all the fields have suitable valid values
@@ -62,6 +61,7 @@ The [high level API](./index.ts) for configuration processing consists of the `f
 ### readConfig()
 
 The `readConfig()` function will find the nearest `wrangler.toml` file, load and parse it, then validate and normalize the values into a `Config` object.
+Note that you should pass the current active environment name in as a parameter. The resulting `Config` object will contain only the fields appropriate to that environment.
 If there are validation errors then it will throw a suitable error.
 
 ## Changing configuration