wrangler 0.0.13 → 0.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wrangler",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "author": "wrangler@cloudflare.com",
   "description": "Command-line interface for all things Cloudflare Workers",
   "bin": {
@@ -72,6 +72,7 @@
     "ink-table": "^3.0.0",
     "ink-testing-library": "^2.1.0",
     "ink-text-input": "^4.0.2",
+    "jest-fetch-mock": "^3.0.3",
     "mime": "^3.0.0",
     "node-fetch": "3.1.1",
     "open": "^8.4.0",

package/src/__tests__/dev.test.tsx

@@ -44,6 +44,7 @@ function renderDev({
   compatibilityFlags,
   usageModel,
   buildCommand = {},
+  enableLocalPersistence = false,
 }: Partial<DevProps>) {
   return render(
     <Dev
@@ -62,6 +63,7 @@ function renderDev({
       compatibilityFlags={compatibilityFlags}
       usageModel={usageModel}
       bindings={bindings}
+      enableLocalPersistence={enableLocalPersistence}
     />
   );
 }

package/src/__tests__/jest.setup.ts

@@ -1,6 +1,13 @@
 import { mockFetchInternal } from "./mock-cfetch";
 import { confirm, prompt } from "../dialogs";
 import { fetchInternal } from "../cfetch/internal";
+import fetchMock from "jest-fetch-mock";
+
+jest.mock("node-fetch", () => jest.requireActual("jest-fetch-mock"));
+fetchMock.doMock(() => {
+  // Any un-mocked fetches should throw
+  throw new Error("Unexpected fetch request");
+});
 
 jest.mock("../cfetch/internal");
 (fetchInternal as jest.Mock).mockImplementation(mockFetchInternal);

package/src/__tests__/logout.test.ts

@@ -0,0 +1,64 @@
+import os from "node:os";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import fetchMock from "jest-fetch-mock";
+import { runWrangler } from "./run-wrangler";
+import { runInTempDir } from "./run-in-tmp";
+import { initialise } from "../user";
+import { mockConsoleMethods } from "./mock-console";
+import { writeUserConfig } from "./whoami.test";
+
+const ORIGINAL_CF_API_TOKEN = process.env.CF_API_TOKEN;
+const ORIGINAL_CF_ACCOUNT_ID = process.env.CF_ACCOUNT_ID;
+
+describe("wrangler", () => {
+  runInTempDir({ homedir: "./home" });
+  const std = mockConsoleMethods();
+
+  beforeEach(() => {
+    delete process.env.CF_API_TOKEN;
+    delete process.env.CF_ACCOUNT_ID;
+  });
+
+  afterEach(() => {
+    // Reset any changes to the environment variables
+    process.env.CF_API_TOKEN = ORIGINAL_CF_API_TOKEN;
+    process.env.CF_ACCOUNT_ID = ORIGINAL_CF_ACCOUNT_ID;
+  });
+
+  describe("logout", () => {
+    it("should exit with a message stating the user is not logged in", async () => {
+      await initialise();
+      await runWrangler("logout");
+      expect(std.out).toMatchInlineSnapshot(`"Not logged in, exiting..."`);
+    });
+
+    it("should logout user that has been properly logged in", async () => {
+      writeUserConfig("some-oauth-tok", "some-refresh-tok");
+
+      // Mock out the response for a request to revoke the auth tokens,
+      // checking the form of the request is as expected.
+      fetchMock.mockResponseOnce(async (req) => {
+        expect(req.url).toEqual("https://dash.cloudflare.com/oauth2/revoke");
+        expect(req.method).toEqual("POST");
+        return "";
+      });
+
+      await initialise();
+      await runWrangler("logout");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "💁  Wrangler is configured with an OAuth token. The token has been successfully revoked
+        Removing ./home/.wrangler/config/default.toml.. success!"
+      `);
+
+      // Make sure that we made the request to logout.
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+
+      // Make sure that logout removed the config file containing the auth tokens.
+      expect(
+        existsSync(path.join(os.homedir(), ".wrangler/config/default.toml"))
+      ).toBe(false);
+    });
+  });
+});

package/src/__tests__/publish.test.ts

@@ -748,6 +748,37 @@ describe("publish", () => {
       );
     });
   });
+
+  describe("custom builds", () => {
+    it("should run a custom build before publishing", async () => {
+      writeWranglerToml({
+        build: {
+          command: `echo "custom build" && echo "export default { fetch(){ return new Response(123)} }" > index.js`,
+        },
+      });
+
+      mockUploadWorkerRequest({
+        expectedBody: "return new Response(123)",
+      });
+      mockSubDomainRequest();
+
+      await runWrangler("publish index.js");
+      expect(stripTimings(std.out)).toMatchInlineSnapshot(`
+        "running:
+        echo \\"custom build\\" && echo \\"export default { fetch(){ return new Response(123)} }\\" > index.js
+        Uploaded
+        test-name
+        (TIMINGS)
+        Deployed
+        test-name
+        (TIMINGS)
+         
+        test-name.test-sub-domain.workers.dev"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+    });
+  });
 });
 
 /** Write a mock wrangler.toml file to disk. */

package/src/__tests__/secret.test.ts

@@ -0,0 +1,206 @@
+import { setMockResponse, unsetAllMocks } from "./mock-cfetch";
+import { runWrangler } from "./run-wrangler";
+import { runInTempDir } from "./run-in-tmp";
+import { mockConfirm, mockPrompt } from "./mock-dialogs";
+import { mockConsoleMethods } from "./mock-console";
+
+describe("wrangler secret", () => {
+  const std = mockConsoleMethods();
+  runInTempDir();
+  afterEach(() => {
+    unsetAllMocks();
+  });
+
+  describe("put", () => {
+    function mockPutRequest(input: { name: string; text: string }) {
+      setMockResponse(
+        "/accounts/:accountId/workers/scripts/:scriptName/secrets",
+        "PUT",
+        ([_url, accountId], { body }) => {
+          expect(accountId).toEqual("some-account-id");
+          const { name, text, type } = JSON.parse(body as string);
+          expect(type).toEqual("secret_text");
+          expect(name).toEqual(input.name);
+          expect(text).toEqual(input.text);
+
+          return { name, type };
+        }
+      );
+    }
+
+    it("should create a secret", async () => {
+      mockPrompt({
+        text: "Enter a secret value:",
+        type: "password",
+        result: "the-secret",
+      });
+
+      mockPutRequest({ name: "the-secret-name", 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(`""`);
+    });
+
+    it("should error without a script name", async () => {
+      let error: Error | undefined;
+      try {
+        await runWrangler("secret put the-key");
+      } catch (e) {
+        error = e;
+      }
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      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."
+      `);
+      expect(error).toMatchInlineSnapshot(`[Error: Missing script name]`);
+    });
+
+    it("warns about being a no-op in local mode", async () => {
+      mockPrompt({
+        text: "Enter a secret value:",
+        type: "password",
+        result: "the-secret",
+      });
+
+      mockPutRequest({ name: "the-secret-name", text: "the-secret" });
+      await runWrangler("secret put the-key --name script-name --local");
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(
+        `"\`wrangler secret put\` is a no-op in --local mode"`
+      );
+    });
+  });
+
+  describe("delete", () => {
+    function mockDeleteRequest(input: {
+      scriptName: string;
+      secretName: string;
+    }) {
+      setMockResponse(
+        "/accounts/:accountId/workers/scripts/:scriptName/secrets/:secretName",
+        "DELETE",
+        ([_url, accountId, scriptName, secretName]) => {
+          expect(accountId).toEqual("some-account-id");
+          expect(scriptName).toEqual(input.scriptName);
+          expect(secretName).toEqual(input.secretName);
+
+          return null;
+        }
+      );
+    }
+    it("should delete a secret", async () => {
+      mockDeleteRequest({ scriptName: "script-name", secretName: "the-key" });
+      mockConfirm({
+        text: "Are you sure you want to permanently delete the variable the-key on the script script-name?",
+        result: true,
+      });
+      await runWrangler("secret delete the-key --name script-name");
+      expect(std.out).toMatchInlineSnapshot(`
+        "🌀 Deleting the secret the-key on script script-name.
+        ✨ Success! Deleted secret the-key"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should error without a script name", async () => {
+      let error: Error | undefined;
+
+      try {
+        await runWrangler("secret delete the-key");
+      } catch (e) {
+        error = e;
+      }
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      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."
+      `);
+      expect(error).toMatchInlineSnapshot(`[Error: Missing script name]`);
+    });
+
+    it("warns about being a no-op in local mode", async () => {
+      mockConfirm({
+        text: "Are you sure you want to permanently delete the variable the-key on the script script-name?",
+        result: true,
+      });
+      await runWrangler("secret delete the-key --name script-name --local");
+      expect(std.out).toMatchInlineSnapshot(
+        `"🌀 Deleting the secret the-key on script script-name."`
+      );
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(
+        `"\`wrangler secret delete\` is a no-op in --local mode"`
+      );
+    });
+  });
+
+  describe("list", () => {
+    function mockListRequest(input: { scriptName: string }) {
+      setMockResponse(
+        "/accounts/:accountId/workers/scripts/:scriptName/secrets",
+        "GET",
+        ([_url, accountId, scriptName]) => {
+          expect(accountId).toEqual("some-account-id");
+          expect(scriptName).toEqual(input.scriptName);
+
+          return [
+            {
+              name: "the-secret-name",
+              type: "secret_text",
+            },
+          ];
+        }
+      );
+    }
+
+    it("should list secrets", async () => {
+      mockListRequest({ scriptName: "script-name" });
+      await runWrangler("secret list --name script-name");
+      expect(std.out).toMatchInlineSnapshot(`
+        "[
+          {
+            \\"name\\": \\"the-secret-name\\",
+            \\"type\\": \\"secret_text\\"
+          }
+        ]"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should error without a script name", async () => {
+      let error: Error | undefined;
+      try {
+        await runWrangler("secret list");
+      } catch (e) {
+        error = e;
+      }
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      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."
+      `);
+      expect(error).toMatchInlineSnapshot(`[Error: Missing script name]`);
+    });
+
+    it("warns about being a no-op in local mode", async () => {
+      await runWrangler("secret list --name script-name --local");
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(
+        `"\`wrangler secret list\` is a no-op in --local mode"`
+      );
+    });
+  });
+});

package/src/__tests__/whoami.test.tsx

@@ -102,7 +102,7 @@ describe("WhoAmI component", () => {
   });
 });
 
-function writeUserConfig(
+export function writeUserConfig(
   oauth_token?: string,
   refresh_token?: string,
   expiration_time?: string

package/src/dev.tsx

@@ -8,7 +8,7 @@ import { Box, Text, useApp, useInput } from "ink";
 import { watch } from "chokidar";
 import clipboardy from "clipboardy";
 import commandExists from "command-exists";
-import { execa } from "execa";
+import { execaCommand } from "execa";
 import fetch from "node-fetch";
 import open from "open";
 import React, { useState, useEffect, useRef } from "react";
@@ -40,6 +40,7 @@ export type DevProps = {
   initialMode: "local" | "remote";
   jsxFactory: undefined | string;
   jsxFragment: undefined | string;
+  enableLocalPersistence: boolean;
   bindings: CfWorkerInit["bindings"];
   public: undefined | string;
   assetPaths: undefined | AssetPaths;
@@ -102,6 +103,7 @@ function Dev(props: DevProps): JSX.Element {
           site={props.assetPaths}
           public={props.public}
           port={port}
+          enableLocalPersistence={props.enableLocalPersistence}
         />
       ) : (
         <Remote
@@ -184,6 +186,7 @@ function Local(props: {
   public: undefined | string;
   site: undefined | AssetPaths;
   port: number;
+  enableLocalPersistence: boolean;
 }) {
   const { inspectorUrl } = useLocalWorker({
     name: props.name,
@@ -191,6 +194,7 @@ function Local(props: {
     format: props.format,
     bindings: props.bindings,
     port: props.port,
+    enableLocalPersistence: props.enableLocalPersistence,
   });
   useInspector({ inspectorUrl, port: 9229, logToTerminal: false });
   return null;
@@ -202,6 +206,7 @@ function useLocalWorker(props: {
   format: CfScriptFormat;
   bindings: CfWorkerInit["bindings"];
   port: number;
+  enableLocalPersistence: boolean;
 }) {
   // TODO: pass vars via command line
   const { bundle, format, bindings, port } = props;
@@ -238,9 +243,9 @@ function useLocalWorker(props: {
         path.join(__dirname, "../miniflare-config-stubs/package.empty.json"),
         "--port",
         port.toString(),
-        "--kv-persist",
-        "--cache-persist",
-        "--do-persist",
+        ...(props.enableLocalPersistence
+          ? ["--kv-persist", "--cache-persist", "--do-persist"]
+          : []),
         ...Object.entries(bindings.vars || {}).flatMap(([key, value]) => {
           return ["--binding", `${key}=${value}`];
         }),
@@ -371,20 +376,21 @@ function useCustomBuild(
     if (!command) return;
     let cmd, interval;
     console.log("running:", command);
-    const commandPieces = command.split(" ");
-    cmd = execa(commandPieces[0], commandPieces.slice(1), {
+    cmd = execaCommand(command, {
       ...(cwd && { cwd }),
+      shell: true,
       stderr: "inherit",
       stdout: "inherit",
     });
     if (watch_dir) {
       watch(watch_dir, { persistent: true, ignoreInitial: true }).on(
         "all",
-        (_event, _path) => {
-          console.log(`The file ${path} changed, restarting build...`);
+        (_event, filePath) => {
+          console.log(`The file ${filePath} changed, restarting build...`);
           cmd.kill();
-          cmd = execa(commandPieces[0], commandPieces.slice(1), {
+          cmd = execaCommand(command, {
             ...(cwd && { cwd }),
+            shell: true,
             stderr: "inherit",
             stdout: "inherit",
           });

package/src/index.tsx

@@ -238,7 +238,7 @@ export async function main(argv: string[]): Promise<void> {
               "  "
             ) + "\n"
           );
-          await execa("npm", ["install", "--prefer-offline"], {
+          await execa("npm", ["install"], {
             stdio: "inherit",
           });
           console.log(`✨ Created package.json`);
@@ -264,12 +264,7 @@ export async function main(argv: string[]): Promise<void> {
           if (shouldInstall) {
             await execa(
               "npm",
-              [
-                "install",
-                `wrangler@${wranglerVersion}`,
-                "--save-dev",
-                "--prefer-offline",
-              ],
+              ["install", `wrangler@${wranglerVersion}`, "--save-dev"],
               {
                 stdio: "inherit",
               }
@@ -309,12 +304,7 @@ export async function main(argv: string[]): Promise<void> {
           );
           await execa(
             "npm",
-            [
-              "install",
-              "@cloudflare/workers-types",
-              "--save-dev",
-              "--prefer-offline",
-            ],
+            ["install", "@cloudflare/workers-types", "--save-dev"],
             { stdio: "inherit" }
           );
           console.log(
@@ -340,12 +330,7 @@ export async function main(argv: string[]): Promise<void> {
           if (shouldInstall) {
             await execa(
               "npm",
-              [
-                "install",
-                "@cloudflare/workers-types",
-                "--save-dev",
-                "--prefer-offline",
-              ],
+              ["install", "@cloudflare/workers-types", "--save-dev"],
               {
                 stdio: "inherit",
               }
@@ -556,6 +541,10 @@ export async function main(argv: string[]): Promise<void> {
         .option("jsx-fragment", {
           describe: "The function that is called for each JSX fragment",
           type: "string",
+        })
+        .option("experimental-enable-local-persistence", {
+          describe: "Enable persistence for this session (only for local mode)",
+          type: "boolean",
         });
     },
     async (args) => {
@@ -623,6 +612,9 @@ export async function main(argv: string[]): Promise<void> {
           initialMode={args.local ? "local" : "remote"}
           jsxFactory={args["jsx-factory"] || envRootObj?.jsx_factory}
           jsxFragment={args["jsx-fragment"] || envRootObj?.jsx_fragment}
+          enableLocalPersistence={
+            args["experimental-enable-local-persistence"] || false
+          }
           accountId={config.account_id}
           assetPaths={getAssetPaths(
             config,
@@ -1088,11 +1080,6 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async (args) => {
-            if (args.local) {
-              throw new NotImplementedError(
-                "--local not implemented for this command yet"
-              );
-            }
             const config = args.config as Config;
 
             // TODO: use environment (how does current wrangler do it?)
@@ -1101,6 +1088,10 @@ export async function main(argv: string[]): Promise<void> {
               throw new Error("Missing script name");
             }
 
+            if (args.local) {
+              console.warn("`wrangler secret put` is a no-op in --local mode");
+            }
+
             if (!args.local) {
               // -- snip, extract --
               const loggedIn = await loginOrRefreshIfRequired();
@@ -1123,6 +1114,13 @@ export async function main(argv: string[]): Promise<void> {
               "Enter a secret value:",
               "password"
             );
+
+            if (args.local) {
+              return;
+            }
+
+            console.log(`🌀 Creating the secret for script ${scriptName}`);
+
             async function submitSecret() {
               return await fetchResult(
                 `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets/`,
@@ -1139,7 +1137,7 @@ export async function main(argv: string[]): Promise<void> {
             }
 
             try {
-              console.log(await submitSecret());
+              await submitSecret();
             } catch (e) {
               if (e.code === 10007) {
                 // upload a draft worker
@@ -1165,10 +1163,11 @@ export async function main(argv: string[]): Promise<void> {
                 );
 
                 // and then try again
-                console.log(await submitSecret());
+                await submitSecret();
                 // TODO: delete the draft worker if this failed too?
               }
             }
+            console.log(`✨ Success! Uploaded secret ${args.key}`);
           }
         )
         .command(
@@ -1191,11 +1190,6 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async (args) => {
-            if (args.local) {
-              throw new NotImplementedError(
-                "--local not implemented for this command yet"
-              );
-            }
             const config = args.config as Config;
 
             // TODO: use environment (how does current wrangler do it?)
@@ -1204,6 +1198,12 @@ export async function main(argv: string[]): Promise<void> {
               throw new Error("Missing script name");
             }
 
+            if (args.local) {
+              console.warn(
+                "`wrangler secret delete` is a no-op in --local mode"
+              );
+            }
+
             if (!args.local) {
               // -- snip, extract --
               const loggedIn = await loginOrRefreshIfRequired();
@@ -1222,17 +1222,24 @@ export async function main(argv: string[]): Promise<void> {
               // -- snip, end --
             }
 
-            if (await confirm("Are you sure you want to delete this secret?")) {
+            if (
+              await confirm(
+                `Are you sure you want to permanently delete the variable ${args.key} on the script ${scriptName}?`
+              )
+            ) {
               console.log(
-                `Deleting the secret ${args.key} on script ${scriptName}.`
+                `🌀 Deleting the secret ${args.key} on script ${scriptName}.`
               );
 
-              console.log(
-                await fetchResult(
-                  `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets/${args.key}`,
-                  { method: "DELETE" }
-                )
+              if (args.local) {
+                return;
+              }
+
+              await fetchResult(
+                `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets/${args.key}`,
+                { method: "DELETE" }
               );
+              console.log(`✨ Success! Deleted secret ${args.key}`);
             }
           }
         )
@@ -1252,11 +1259,6 @@ export async function main(argv: string[]): Promise<void> {
               });
           },
           async (args) => {
-            if (args.local) {
-              throw new NotImplementedError(
-                "--local not implemented for this command yet"
-              );
-            }
             const config = args.config as Config;
 
             // TODO: use environment (how does current wrangler do it?)
@@ -1265,6 +1267,10 @@ export async function main(argv: string[]): Promise<void> {
               throw new Error("Missing script name");
             }
 
+            if (args.local) {
+              console.warn("`wrangler secret list` is a no-op in --local mode");
+            }
+
             if (!args.local) {
               // -- snip, extract --
               const loggedIn = await loginOrRefreshIfRequired();
@@ -1283,9 +1289,17 @@ export async function main(argv: string[]): Promise<void> {
               // -- snip, end --
             }
 
+            if (args.local) {
+              return;
+            }
+
             console.log(
-              await fetchResult(
-                `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets`
+              JSON.stringify(
+                await fetchResult(
+                  `/accounts/${config.account_id}/workers/scripts/${scriptName}/secrets`
+                ),
+                null,
+                "  "
               )
             );
           }