wrangler 0.0.0-e95bea2 → 0.0.0-ea8e701

package/src/__tests__/dev.test.tsx

@@ -9,7 +9,7 @@ import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 import writeWranglerToml from "./helpers/write-wrangler-toml";
 
-describe("Dev component", () => {
+describe("wrangler dev", () => {
   mockAccountId();
   mockApiToken();
   runInTempDir();
@@ -37,6 +37,57 @@ describe("Dev component", () => {
         %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
       `);
     });
+
+    it("should use `main` from the top-level environment", async () => {
+      writeWranglerToml({
+        main: "index.js",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev");
+      expect((Dev as jest.Mock).mock.calls[0][0].entry.file).toMatch(
+        /index\.js$/
+      );
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should use `main` from a named environment", async () => {
+      writeWranglerToml({
+        env: {
+          ENV1: {
+            main: "index.js",
+          },
+        },
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev --env=ENV1");
+      expect((Dev as jest.Mock).mock.calls[0][0].entry.file).toMatch(
+        /index\.js$/
+      );
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should use `main` from a named environment, rather than the top-level", async () => {
+      writeWranglerToml({
+        main: "other.js",
+        env: {
+          ENV1: {
+            main: "index.js",
+          },
+        },
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev --env=ENV1");
+      expect((Dev as jest.Mock).mock.calls[0][0].entry.file).toMatch(
+        /index\.js$/
+      );
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
   });
 
   describe("host", () => {
@@ -135,7 +186,7 @@ describe("Dev component", () => {
       });
     });
 
-    it("should, in order, use args.host/config.dev.host/args.routes/config.route/config.routes", async () => {
+    it("should, in order, use args.host/config.dev.host/args.routes/(config.route|config.routes)", async () => {
       // This test might seem like it's testing implementation details, but let's be specific and consider it a spec
 
       fs.writeFileSync("index.js", `export default {};`);
@@ -158,7 +209,6 @@ describe("Dev component", () => {
       writeWranglerToml({
         main: "index.js",
         route: "https://4.some-host.com/some/path/*",
-        routes: ["http://5.some-host.com/some/path/*"],
       });
       await runWrangler("dev");
       expect((Dev as jest.Mock).mock.calls[0][0].zone).toEqual({
@@ -172,7 +222,6 @@ describe("Dev component", () => {
       writeWranglerToml({
         main: "index.js",
         route: "https://4.some-host.com/some/path/*",
-        routes: ["http://5.some-host.com/some/path/*"],
       });
       await runWrangler("dev --routes http://3.some-host.com/some/path/*");
       expect((Dev as jest.Mock).mock.calls[0][0].zone).toEqual({
@@ -189,7 +238,6 @@ describe("Dev component", () => {
           host: `2.some-host.com`,
         },
         route: "4.some-host.com/some/path/*",
-        routes: ["5.some-host.com/some/path/*"],
       });
       await runWrangler("dev --routes http://3.some-host.com/some/path/*");
       expect((Dev as jest.Mock).mock.calls[0][0].zone).toEqual({
@@ -206,7 +254,6 @@ describe("Dev component", () => {
           host: `2.some-host.com`,
         },
         route: "4.some-host.com/some/path/*",
-        routes: ["5.some-host.com/some/path/*"],
       });
       await runWrangler(
         "dev --routes http://3.some-host.com/some/path/* --host 1.some-host.com"
@@ -230,6 +277,15 @@ describe("Dev component", () => {
         `"Could not find zone for some-host.com"`
       );
     });
+
+    it("should not try to resolve a zone when starting in local mode", async () => {
+      writeWranglerToml({
+        main: "index.js",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev --host some-host.com --local");
+      expect((Dev as jest.Mock).mock.calls[0][0].zone).toEqual(undefined);
+    });
   });
 
   describe("custom builds", () => {
@@ -247,11 +303,11 @@ describe("Dev component", () => {
       );
 
       // and the command would pass through
-      expect((Dev as jest.Mock).mock.calls[0][0].buildCommand).toEqual({
+      expect((Dev as jest.Mock).mock.calls[0][0].build).toEqual({
         command:
           "node -e \"console.log('custom build'); require('fs').writeFileSync('index.js', 'export default { fetch(){ return new Response(123) } }')\"",
         cwd: undefined,
-        watch_dir: undefined,
+        watch_dir: "src",
       });
       expect(std.out).toMatchInlineSnapshot(
         `"running: node -e \\"console.log('custom build'); require('fs').writeFileSync('index.js', 'export default { fetch(){ return new Response(123) } }')\\""`
@@ -355,7 +411,7 @@ describe("Dev component", () => {
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
 
-    it("should use to `local_protocol` from `wrangler.toml`, if available", async () => {
+    it("should use `local_protocol` from `wrangler.toml`, if available", async () => {
       writeWranglerToml({
         main: "index.js",
         dev: {
@@ -389,6 +445,86 @@ describe("Dev component", () => {
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
   });
+
+  describe("ip", () => {
+    it("should default ip to localhost", async () => {
+      writeWranglerToml({
+        main: "index.js",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev");
+      expect((Dev as jest.Mock).mock.calls[0][0].ip).toEqual("localhost");
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should use to `ip` from `wrangler.toml`, if available", async () => {
+      writeWranglerToml({
+        main: "index.js",
+        dev: {
+          ip: "0.0.0.0",
+        },
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev");
+      expect((Dev as jest.Mock).mock.calls[0][0].ip).toEqual("0.0.0.0");
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should use --ip command line arg, if provided", async () => {
+      writeWranglerToml({
+        main: "index.js",
+        dev: {
+          ip: "1.1.1.1",
+        },
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev --ip=0.0.0.0");
+      expect((Dev as jest.Mock).mock.calls[0][0].ip).toEqual("0.0.0.0");
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+  });
+
+  describe("durable_objects", () => {
+    it("should warn if there is one or more remote Durable Object", async () => {
+      writeWranglerToml({
+        main: "index.js",
+        durable_objects: {
+          bindings: [
+            { name: "NAME_1", class_name: "CLASS_1" },
+            {
+              name: "NAME_2",
+              class_name: "CLASS_2",
+              script_name: "SCRIPT_A",
+            },
+            { name: "NAME_3", class_name: "CLASS_3" },
+            {
+              name: "NAME_4",
+              class_name: "CLASS_4",
+              script_name: "SCRIPT_B",
+            },
+          ],
+        },
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev");
+      expect((Dev as jest.Mock).mock.calls[0][0].ip).toEqual("localhost");
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`
+        "WARNING: You have Durable Object bindings, which are not defined locally in the worker being developed.
+        Be aware that changes to the data stored in these Durable Objects will be permanent and affect the live instances.
+        Remote Durable Objects that are affected:
+        - {\\"name\\":\\"NAME_2\\",\\"class_name\\":\\"CLASS_2\\",\\"script_name\\":\\"SCRIPT_A\\"}
+        - {\\"name\\":\\"NAME_4\\",\\"class_name\\":\\"CLASS_4\\",\\"script_name\\":\\"SCRIPT_B\\"}"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+  });
 });
 
 function mockGetZones(domain: string, zones: { id: string }[] = []) {

package/src/__tests__/guess-worker-format.test.ts

@@ -1,10 +1,12 @@
 import { writeFile } from "fs/promises";
 import path from "path";
 import guessWorkerFormat from "../entry";
+import { mockConsoleMethods } from "./helpers/mock-console";
 import { runInTempDir } from "./helpers/run-in-tmp";
 
 describe("guess worker format", () => {
   runInTempDir();
+  const std = mockConsoleMethods();
   it('should detect a "modules" worker', async () => {
     await writeFile("./index.ts", "export default {};");
     // Note that this isn't actually a valid worker, because it's missing
@@ -39,7 +41,7 @@ describe("guess worker format", () => {
         "service-worker"
       )
     ).rejects.toThrow(
-      "You configured this worker to be a 'service-worker', but the file you are trying to build appears to have ES module exports. Please pass `--format modules`, or simply remove the configuration."
+      "You configured this worker to be a 'service-worker', but the file you are trying to build appears to have a `default` export like a module worker. Please pass `--format modules`, or simply remove the configuration."
     );
   });
 
@@ -55,4 +57,27 @@ describe("guess worker format", () => {
       "You configured this worker to be 'modules', but the file you are trying to build doesn't export a handler. Please pass `--format service-worker`, or simply remove the configuration."
     );
   });
+
+  it("should not error if a .js entry point has jsx", async () => {
+    await writeFile("./index.js", "console.log(<div/>)");
+    const guess = await guessWorkerFormat(
+      path.join(process.cwd(), "./index.js"),
+      process.cwd(),
+      undefined
+    );
+    expect(guess).toBe("service-worker");
+  });
+
+  it("logs a warning when a worker has exports, but not a default one", async () => {
+    await writeFile("./index.ts", "export const foo = 1;");
+    const guess = await guessWorkerFormat(
+      path.join(process.cwd(), "./index.ts"),
+      process.cwd(),
+      undefined
+    );
+    expect(guess).toBe("service-worker");
+    expect(std.warn).toMatchInlineSnapshot(
+      `"The entrypoint index.ts has exports like an ES Module, but hasn't defined a default export like a module worker normally would. Building the worker using \\"service-worker\\" format..."`
+    );
+  });
 });

package/src/__tests__/helpers/mock-account-id.ts

@@ -1,3 +1,5 @@
+import { reinitialiseAuthTokens } from "../../user";
+
 const ORIGINAL_CLOUDFLARE_API_TOKEN = process.env.CLOUDFLARE_API_TOKEN;
 const ORIGINAL_CLOUDFLARE_ACCOUNT_ID = process.env.CLOUDFLARE_ACCOUNT_ID;
 
@@ -16,6 +18,8 @@ export function mockApiToken({
     } else {
       process.env.CLOUDFLARE_API_TOKEN = apiToken;
     }
+    // Now we have updated the environment, we must reinitialize the user auth state.
+    reinitialiseAuthTokens();
   });
   afterEach(() => {
     process.env.CLOUDFLARE_API_TOKEN = ORIGINAL_CLOUDFLARE_API_TOKEN;

package/src/__tests__/helpers/mock-kv.ts

@@ -1,18 +1,15 @@
 import { createFetchResult, setMockRawResponse } from "./mock-cfetch";
+import type { NamespaceKeyInfo } from "../../kv";
 
 export function mockKeyListRequest(
   expectedNamespaceId: string,
-  expectedKeys: string[],
+  expectedKeys: NamespaceKeyInfo[],
   keysPerRequest = 1000,
   blankCursorValue: "" | undefined | null = undefined
 ) {
   const requests = { count: 0 };
   // See https://api.cloudflare.com/#workers-kv-namespace-list-a-namespace-s-keys
-  const expectedKeyObjects = expectedKeys.map((name) => ({
-    name,
-    expiration: 123456789,
-    metadata: {},
-  }));
+
   setMockRawResponse(
     "/accounts/:accountId/storage/kv/namespaces/:namespaceId/keys",
     "GET",
@@ -20,19 +17,15 @@ export function mockKeyListRequest(
       requests.count++;
       expect(accountId).toEqual("some-account-id");
       expect(namespaceId).toEqual(expectedNamespaceId);
-      if (expectedKeyObjects.length <= keysPerRequest) {
-        return createFetchResult(expectedKeyObjects);
+      if (expectedKeys.length <= keysPerRequest) {
+        return createFetchResult(expectedKeys);
       } else {
         const start = parseInt(query.get("cursor") ?? "0") || 0;
         const end = start + keysPerRequest;
-        const cursor = end < expectedKeyObjects.length ? end : blankCursorValue;
-        return createFetchResult(
-          expectedKeyObjects.slice(start, end),
-          true,
-          [],
-          [],
-          { cursor }
-        );
+        const cursor = end < expectedKeys.length ? end : blankCursorValue;
+        return createFetchResult(expectedKeys.slice(start, end), true, [], [], {
+          cursor,
+        });
       }
     }
   );

package/src/__tests__/helpers/mock-oauth-flow.ts

@@ -0,0 +1,178 @@
+import { ChildProcess } from "child_process";
+import fetchMock from "jest-fetch-mock";
+import { Request } from "undici";
+const { fetch } = jest.requireActual("undici") as {
+  fetch: (input: string) => Promise<unknown>;
+};
+
+// the response to send when wrangler wants an oauth grant
+let oauthGrantResponse: GrantResponseOptions | "timeout" = {};
+
+/**
+ * A mock implementation for `openInBrowser` that sends an oauth grant response
+ * to wrangler. Use it like this:
+ *
+ * ```js
+ * jest.mock("../open-in-browser");
+ * (openInBrowser as jest.Mock).mockImplementation(mockOpenInBrowser);
+ * ```
+ */
+export const mockOpenInBrowser = async (url: string, ..._args: unknown[]) => {
+  const { searchParams } = new URL(url);
+  if (oauthGrantResponse === "timeout") {
+    throw "unimplemented";
+  } else {
+    const queryParams = toQueryParams(oauthGrantResponse, searchParams);
+    // don't await this -- it will block the rest of the login flow
+    fetch(`${searchParams.get("redirect_uri")}?${queryParams}`).catch((e) => {
+      throw new Error(
+        "Failed to send OAuth Grant to wrangler, maybe the server was closed?",
+        e as Error
+      );
+    });
+    return new ChildProcess();
+  }
+};
+
+/**
+ * Functions to help with mocking various parts of the OAuth Flow
+ */
+export const mockOAuthFlow = () => {
+  afterEach(() => {
+    fetchMock.resetMocks();
+  });
+
+  const mockGrantAuthorization = ({
+    respondWith,
+  }: {
+    respondWith: "timeout" | "success" | "failure" | GrantResponseOptions;
+  }) => {
+    if (respondWith === "failure") {
+      oauthGrantResponse = {
+        error: "access_denied",
+      };
+    } else if (respondWith === "success") {
+      oauthGrantResponse = {
+        code: "test-oauth-code",
+      };
+    } else if (respondWith === "timeout") {
+      oauthGrantResponse = "timeout";
+    } else {
+      oauthGrantResponse = respondWith;
+    }
+  };
+
+  const mockRevokeAuthorization = () => {
+    const outcome = {
+      actual: new Request("https://example.org"),
+      expected: new Request("https://dash.cloudflare.com/oauth2/revoke", {
+        method: "POST",
+      }),
+    };
+
+    fetchMock.mockIf(outcome.expected.url, async (req) => {
+      outcome.actual = req;
+      return "";
+    });
+
+    return outcome;
+  };
+
+  const mockGrantAccessToken = ({
+    respondWith,
+  }: {
+    respondWith: MockTokenResponse;
+  }) => {
+    const outcome = {
+      actual: new Request("https://example.org"),
+      expected: new Request("https://dash.cloudflare.com/oauth2/token", {
+        method: "POST",
+      }),
+    };
+
+    fetchMock.mockOnceIf(outcome.expected.url, async (req) => {
+      outcome.actual = req;
+      return makeTokenResponse(respondWith);
+    });
+
+    return outcome;
+  };
+
+  return {
+    mockGrantAuthorization,
+    mockRevokeAuthorization,
+    mockGrantAccessToken,
+  };
+};
+
+type GrantResponseOptions = {
+  code?: string;
+  error?: ErrorType | ErrorType[];
+};
+
+const toQueryParams = (
+  { code, error }: GrantResponseOptions,
+  wranglerRequestParams: URLSearchParams
+): string => {
+  const queryParams = [];
+  if (code) {
+    queryParams.push(`code=${code}`);
+  }
+  if (error) {
+    const stringifiedErr = Array.isArray(error) ? error.join(",") : error;
+    queryParams.push(`error=${stringifiedErr}`);
+  }
+
+  queryParams.push(`state=${wranglerRequestParams.get("state")}`);
+
+  return queryParams.join("&");
+};
+
+type ErrorType =
+  | "invalid_request"
+  | "invalid_grant"
+  | "unauthorized_client"
+  | "access_denied"
+  | "unsupported_response_type"
+  | "invalid_scope"
+  | "server_error"
+  | "temporarily_unavailable"
+  | "invalid_client"
+  | "unsupported_grant_type"
+  | "invalid_json"
+  | "invalid_token"
+  | "test-token-grant-error";
+
+type MockTokenResponse =
+  | "ok"
+  | "error"
+  | {
+      access_token: string;
+      expires_in: number;
+      refresh_token: string;
+      scope: string;
+    }
+  | {
+      error: ErrorType;
+    };
+
+const makeTokenResponse = (partialResponse: MockTokenResponse): string => {
+  let fullResponse: MockTokenResponse;
+
+  if (partialResponse === "ok") {
+    fullResponse = {
+      access_token: "test-access-token",
+      expires_in: 100000,
+      refresh_token: "test-refresh-token",
+      scope: "account:read",
+    };
+  } else if (partialResponse === "error") {
+    fullResponse = {
+      error: "test-token-grant-error",
+    };
+  } else {
+    fullResponse = partialResponse;
+  }
+
+  return JSON.stringify(fullResponse);
+};

package/src/__tests__/helpers/run-in-tmp.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import os from "node:os";
 import * as path from "node:path";
+import { reinitialiseAuthTokens } from "../../user";
 
 const originalCwd = process.cwd();
 
@@ -19,6 +20,8 @@ export function runInTempDir({ homedir }: { homedir?: string } = {}) {
       // This is because the module gets transpiled so that the "method" `homedir()` gets converted to a
       // getter that is not configurable (and so cannot be spied upon).
       jest.spyOn(os, "homedir").mockReturnValue(homedir);
+      // Now that we have changed the home directory location, we must reinitialize the user auth state
+      reinitialiseAuthTokens();
     }
   });
 

package/src/__tests__/index.test.ts

@@ -36,7 +36,6 @@ describe("wrangler", () => {
 
         Commands:
           wrangler init [name]       📥 Create a wrangler.toml configuration file
-          wrangler whoami            🕵️  Retrieve your user info and test your auth config
           wrangler dev [script]      👂 Start a local server for developing your worker
           wrangler publish [script]  🆙 Publish your Worker to Cloudflare.
           wrangler tail [name]       🦚 Starts a log tailing session for a published Worker.
@@ -46,6 +45,9 @@ describe("wrangler", () => {
           wrangler kv:bulk           💪 Interact with multiple Workers KV key-value pairs at once
           wrangler pages             ⚡️ Configure Cloudflare Pages
           wrangler r2                📦 Interact with an R2 store
+          wrangler login             🔓 Login to Cloudflare
+          wrangler logout            🚪 Logout from Cloudflare
+          wrangler whoami            🕵️  Retrieve your user info and test your auth config
 
         Flags:
           -c, --config      Path to .toml configuration file  [string]
@@ -63,7 +65,7 @@ describe("wrangler", () => {
       await expect(
         runWrangler("invalid-command")
       ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"Unknown command: invalid-command."`
+        `"Unknown argument: invalid-command"`
       );
 
       expect(std.out).toMatchInlineSnapshot(`""`);
@@ -72,7 +74,6 @@ describe("wrangler", () => {
 
         Commands:
           wrangler init [name]       📥 Create a wrangler.toml configuration file
-          wrangler whoami            🕵️  Retrieve your user info and test your auth config
           wrangler dev [script]      👂 Start a local server for developing your worker
           wrangler publish [script]  🆙 Publish your Worker to Cloudflare.
           wrangler tail [name]       🦚 Starts a log tailing session for a published Worker.
@@ -82,6 +83,9 @@ describe("wrangler", () => {
           wrangler kv:bulk           💪 Interact with multiple Workers KV key-value pairs at once
           wrangler pages             ⚡️ Configure Cloudflare Pages
           wrangler r2                📦 Interact with an R2 store
+          wrangler login             🔓 Login to Cloudflare
+          wrangler logout            🚪 Logout from Cloudflare
+          wrangler whoami            🕵️  Retrieve your user info and test your auth config
 
         Flags:
           -c, --config      Path to .toml configuration file  [string]
@@ -89,7 +93,7 @@ describe("wrangler", () => {
           -v, --version     Show version number  [boolean]
               --legacy-env  Use legacy environments  [boolean]
 
-        Unknown command: invalid-command."
+        Unknown argument: invalid-command"
       `);
     });
   });
@@ -812,14 +816,6 @@ describe("wrangler", () => {
       expect(fs.existsSync("./wrangler.toml")).toBe(true);
     });
 
-    it("should error if `--type` is used", async () => {
-      await expect(
-        runWrangler("init --type")
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"The --type option is no longer supported."`
-      );
-    });
-
     it("should error if `--type javascript` is used", async () => {
       await expect(
         runWrangler("init --type javascript")
@@ -854,7 +850,7 @@ describe("wrangler", () => {
               Try using \`wrangler dev\` to to try out a worker during development.
               "
             `);
-      await expect(runWrangler("preview GET 'Some Body'")).rejects
+      await expect(runWrangler(`preview GET "SomeBody"`)).rejects
         .toThrowErrorMatchingInlineSnapshot(`
               "DEPRECATION WARNING:
               The \`wrangler preview\` command has been deprecated.

package/src/__tests__/jest.setup.ts

@@ -5,7 +5,9 @@ import {
   getCloudflareAPIBaseURL,
 } from "../cfetch/internal";
 import { confirm, prompt } from "../dialogs";
+import openInBrowser from "../open-in-browser";
 import { mockFetchInternal, mockFetchKVGetValue } from "./helpers/mock-cfetch";
+import { mockOpenInBrowser as mockOpenInBrowserForOAuthFlow } from "./helpers/mock-oauth-flow";
 import { MockWebSocket } from "./helpers/mock-web-socket";
 
 jest.mock("ws", () => {
@@ -67,3 +69,6 @@ jest.mock("../dev/dev", () => {
     return null;
   });
 });
+
+jest.mock("../open-in-browser");
+(openInBrowser as jest.Mock).mockImplementation(mockOpenInBrowserForOAuthFlow);