wrangler 2.0.12 → 2.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wrangler",
-  "version": "2.0.12",
+  "version": "2.0.14",
   "author": "wrangler@cloudflare.com",
   "description": "Command-line interface for all things Cloudflare Workers",
   "bin": {
@@ -99,7 +99,7 @@
     "timeago.js": "^4.0.2",
     "tmp-promise": "^3.0.3",
     "ts-dedent": "^2.2.0",
-    "undici": "^5.3.0",
+    "undici": "^5.5.1",
     "update-check": "^1.5.4",
     "ws": "^8.5.0",
     "yargs": "^17.4.1"

package/src/__tests__/jest.setup.ts

@@ -75,3 +75,33 @@ jest.mock("../dev/dev", () => {
 // Make sure that we don't accidentally try to open a browser window when running tests.
 // We will actually provide a mock implementation for `openInBrowser()` within relevant tests.
 jest.mock("../open-in-browser");
+
+// Mock the functions involved in getAuthURL so we don't take snapshots of the constantly changing URL.
+jest.mock("../generate-auth-url", () => {
+  return {
+    generateRandomState: jest.fn().mockImplementation(() => "MOCK_STATE_PARAM"),
+    generateAuthUrl: jest
+      .fn()
+      .mockImplementation(({ authUrl, clientId, callbackUrl, scopes }) => {
+        return (
+          authUrl +
+          `?response_type=code&` +
+          `client_id=${encodeURIComponent(clientId)}&` +
+          `redirect_uri=${encodeURIComponent(callbackUrl)}&` +
+          // we add offline_access manually for every request
+          `scope=${encodeURIComponent(
+            [...scopes, "offline_access"].join(" ")
+          )}&` +
+          `state=MOCK_STATE_PARAM&` +
+          `code_challenge=${encodeURIComponent("MOCK_CODE_CHALLENGE")}&` +
+          `code_challenge_method=S256`
+        );
+      }),
+  };
+});
+
+jest.mock("../generate-random-state", () => {
+  return {
+    generateRandomState: jest.fn().mockImplementation(() => "MOCK_STATE_PARAM"),
+  };
+});

package/src/__tests__/kv.test.ts

@@ -448,11 +448,10 @@ describe("wrangler", () => {
       });
 
       it("should put a key with a value loaded from a given path", async () => {
-        const buf = Buffer.from("file-contents", "utf-8");
-        writeFileSync("foo.txt", buf);
+        writeFileSync("foo.txt", "file-contents", "utf-8");
         const requests = mockKeyPutRequest("some-namespace-id", {
           key: "my-key",
-          value: buf,
+          value: "file-contents",
         });
         await runWrangler(
           "kv:key put my-key --namespace-id some-namespace-id --path foo.txt"
@@ -464,26 +463,6 @@ describe("wrangler", () => {
         expect(requests.count).toEqual(1);
       });
 
-      it("should put a key with a binary value loaded from a given path", async () => {
-        const buf = Buffer.from(
-          "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAiSURBVHgB7coxEQAACMPAgH/PgAM6dGwu49fA/deIBXrgAj2cAhIFT4QxAAAAAElFTkSuQmCC",
-          "base64"
-        );
-        writeFileSync("test.png", buf);
-        const requests = mockKeyPutRequest("another-namespace-id", {
-          key: "my-key",
-          value: buf,
-        });
-        await runWrangler(
-          "kv:key put my-key --namespace-id another-namespace-id --path test.png"
-        );
-        expect(std.out).toMatchInlineSnapshot(
-          `"Writing the contents of test.png to the key \\"my-key\\" on namespace another-namespace-id."`
-        );
-        expect(std.err).toMatchInlineSnapshot(`""`);
-        expect(requests.count).toEqual(1);
-      });
-
       it("should error if no key is provided", async () => {
         await expect(
           runWrangler("kv:key put")

package/src/__tests__/publish.test.ts

@@ -66,7 +66,6 @@ describe("publish", () => {
       writeWorkerSource();
       mockSubDomainRequest();
       mockUploadWorkerRequest();
-
       mockOAuthServerCallback();
       const accessTokenRequest = mockGrantAccessToken({ respondWith: "ok" });
       mockGrantAuthorization({ respondWith: "success" });
@@ -79,6 +78,7 @@ describe("publish", () => {
 
       expect(std.out).toMatchInlineSnapshot(`
         "Attempting to login via OAuth...
+        Opening a link in your default browser: https://dash.cloudflare.com/oauth2/auth?response_type=code&client_id=54d11594-84e4-41aa-b438-e81b8fa78ee7&redirect_uri=http%3A%2F%2Flocalhost%3A8976%2Foauth%2Fcallback&scope=account%3Aread%20user%3Aread%20workers%3Awrite%20workers_kv%3Awrite%20workers_routes%3Awrite%20workers_scripts%3Awrite%20workers_tail%3Aread%20pages%3Awrite%20zone%3Aread%20offline_access&state=MOCK_STATE_PARAM&code_challenge=MOCK_CODE_CHALLENGE&code_challenge_method=S256
         Successfully logged in.
         Uploaded test-name (TIMINGS)
         Published test-name (TIMINGS)
@@ -108,6 +108,7 @@ describe("publish", () => {
 
       expect(std.out).toMatchInlineSnapshot(`
         "Attempting to login via OAuth...
+        Opening a link in your default browser: https://dash.cloudflare.com/oauth2/auth?response_type=code&client_id=54d11594-84e4-41aa-b438-e81b8fa78ee7&redirect_uri=http%3A%2F%2Flocalhost%3A8976%2Foauth%2Fcallback&scope=account%3Aread%20user%3Aread%20workers%3Awrite%20workers_kv%3Awrite%20workers_routes%3Awrite%20workers_scripts%3Awrite%20workers_tail%3Aread%20pages%3Awrite%20zone%3Aread%20offline_access&state=MOCK_STATE_PARAM&code_challenge=MOCK_CODE_CHALLENGE&code_challenge_method=S256
         Successfully logged in.
         Uploaded test-name (TIMINGS)
         Published test-name (TIMINGS)

package/src/__tests__/user.test.ts

@@ -46,6 +46,7 @@ describe("User", () => {
 
       expect(std.out).toMatchInlineSnapshot(`
         "Attempting to login via OAuth...
+        Opening a link in your default browser: https://dash.cloudflare.com/oauth2/auth?response_type=code&client_id=54d11594-84e4-41aa-b438-e81b8fa78ee7&redirect_uri=http%3A%2F%2Flocalhost%3A8976%2Foauth%2Fcallback&scope=account%3Aread%20user%3Aread%20workers%3Awrite%20workers_kv%3Awrite%20workers_routes%3Awrite%20workers_scripts%3Awrite%20workers_tail%3Aread%20pages%3Awrite%20zone%3Aread%20offline_access&state=MOCK_STATE_PARAM&code_challenge=MOCK_CODE_CHALLENGE&code_challenge_method=S256
         Successfully logged in."
       `);
 

package/src/generate-auth-url.ts

@@ -0,0 +1,33 @@
+interface GenerateAuthUrlProps {
+  authUrl: string;
+  clientId: string;
+  callbackUrl: string;
+  scopes: string[];
+  stateQueryParam: string;
+  codeChallenge: string;
+}
+
+/**
+ * generateAuthUrl was extracted from getAuthURL in user.tsx
+ * to make it possible to mock the generated URL
+ */
+export const generateAuthUrl = ({
+  authUrl,
+  clientId,
+  callbackUrl,
+  scopes,
+  stateQueryParam,
+  codeChallenge,
+}: GenerateAuthUrlProps) => {
+  return (
+    authUrl +
+    `?response_type=code&` +
+    `client_id=${encodeURIComponent(clientId)}&` +
+    `redirect_uri=${encodeURIComponent(callbackUrl)}&` +
+    // we add offline_access manually for every request
+    `scope=${encodeURIComponent([...scopes, "offline_access"].join(" "))}&` +
+    `state=${stateQueryParam}&` +
+    `code_challenge=${encodeURIComponent(codeChallenge)}&` +
+    `code_challenge_method=S256`
+  );
+};

package/src/generate-random-state.ts

@@ -0,0 +1,16 @@
+import { webcrypto as crypto } from "node:crypto";
+import { PKCE_CHARSET } from "./user";
+
+/**
+ * Generates random state to be passed for anti-csrf.
+ * extracted from  user.tsx to make it possible to
+ * mock the generated URL
+ */
+export function generateRandomState(lengthOfState: number): string {
+  const output = new Uint32Array(lengthOfState);
+  // @ts-expect-error crypto's types aren't there yet
+  crypto.getRandomValues(output);
+  return Array.from(output)
+    .map((num: number) => PKCE_CHARSET[num % PKCE_CHARSET.length])
+    .join("");
+}

package/src/index.tsx

@@ -48,7 +48,6 @@ import {
   parsePackageJSON,
   parseTOML,
   readFileSync,
-  readFileSyncToBuffer,
 } from "./parse";
 import publish from "./publish";
 import { createR2Bucket, deleteR2Bucket, listR2Buckets } from "./r2";
@@ -2273,7 +2272,7 @@ function createCLIParser(argv: string[]) {
             const namespaceId = getKVNamespaceId(args, config);
             // One of `args.path` and `args.value` must be defined
             const value = args.path
-              ? readFileSyncToBuffer(args.path)
+              ? readFileSync(args.path)
               : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 args.value!;
 

package/src/kv.ts

@@ -111,7 +111,7 @@ export async function deleteKVNamespace(
  */
 export interface KeyValue {
   key: string;
-  value: string | Buffer;
+  value: string;
   expiration?: number;
   expiration_ttl?: number;
   metadata?: object;

package/src/open-in-browser.ts

@@ -10,10 +10,8 @@ import { logger } from "./logger";
  * @param url the URL to point the browser at
  */
 export default async function openInBrowser(url: string): Promise<void> {
-  const errorMessage = `Failed to open ${url} in a browser`;
-
   const childProcess = await open(url);
   childProcess.on("error", () => {
-    logger.warn(errorMessage);
+    logger.warn("Failed to open");
   });
 }

package/src/parse.ts

@@ -139,25 +139,6 @@ export function parseJSON<T>(input: string, file?: string): T {
   }
 }
 
-/**
- * Reads a file into a node Buffer.
- */
-export function readFileSyncToBuffer(file: string): Buffer {
-  try {
-    return fs.readFileSync(file);
-  } catch (err) {
-    const { message } = err as Error;
-    throw new ParseError({
-      text: `Could not read file: ${file}`,
-      notes: [
-        {
-          text: message.replace(file, resolve(file)),
-        },
-      ],
-    });
-  }
-}
-
 /**
  * Reads a file and parses it based on its type.
  */

package/src/user.tsx

@@ -223,6 +223,8 @@ import { fetch } from "undici";
 import { getCloudflareApiBaseUrl } from "./cfetch";
 import { purgeConfigCaches } from "./config-cache";
 import { getEnvironmentVariableFactory } from "./environment-variables";
+import { generateAuthUrl } from "./generate-auth-url";
+import { generateRandomState } from "./generate-random-state";
 import { logger } from "./logger";
 import openInBrowser from "./open-in-browser";
 import { parseTOML, readFileSync } from "./parse";
@@ -591,7 +593,7 @@ const RECOMMENDED_STATE_LENGTH = 32;
 /**
  * Character set to generate code verifier defined in rfc7636.
  */
-const PKCE_CHARSET =
+export const PKCE_CHARSET =
   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
 
 /**
@@ -641,17 +643,14 @@ export async function getAuthURL(scopes = ScopeKeys): Promise<string> {
     stateQueryParam,
   });
 
-  return (
-    AUTH_URL +
-    `?response_type=code&` +
-    `client_id=${encodeURIComponent(CLIENT_ID)}&` +
-    `redirect_uri=${encodeURIComponent(CALLBACK_URL)}&` +
-    // we add offline_access manually for every request
-    `scope=${encodeURIComponent([...scopes, "offline_access"].join(" "))}&` +
-    `state=${stateQueryParam}&` +
-    `code_challenge=${encodeURIComponent(codeChallenge)}&` +
-    `code_challenge_method=S256`
-  );
+  return generateAuthUrl({
+    authUrl: AUTH_URL,
+    clientId: CLIENT_ID,
+    callbackUrl: CALLBACK_URL,
+    scopes,
+    stateQueryParam,
+    codeChallenge,
+  });
 }
 
 type TokenResponse =
@@ -863,18 +862,6 @@ async function generatePKCECodes(): Promise<PKCECodes> {
   return { codeChallenge, codeVerifier };
 }
 
-/**
- * Generates random state to be passed for anti-csrf.
- */
-function generateRandomState(lengthOfState: number): string {
-  const output = new Uint32Array(lengthOfState);
-  // @ts-expect-error crypto's types aren't there yet
-  crypto.getRandomValues(output);
-  return Array.from(output)
-    .map((num: number) => PKCE_CHARSET[num % PKCE_CHARSET.length])
-    .join("");
-}
-
 /**
  * Writes a a wrangler config file (auth credentials) to disk,
  * and updates the user auth state with the new credentials.
@@ -1013,6 +1000,7 @@ export async function login(props?: LoginProps): Promise<boolean> {
     server.listen(8976);
   });
 
+  logger.log(`Opening a link in your default browser: ${urlToOpen}`);
   await openInBrowser(urlToOpen);
 
   return Promise.race([timerPromise, loginPromise]);

package/templates/static-asset-facade.js

@@ -35,7 +35,7 @@ export default {
     } catch (e) {
       console.error(e);
       // if an error is thrown then serve from actual worker
-      return worker.fetch(request);
+      return worker.fetch(request, env, ctx);
       // TODO: throw here if worker is not available
       // (which implies it may be a service-worker)
     }