wrangler 0.0.0-efa548c → 0.0.0-fb43821

package/README.md

@@ -0,0 +1,51 @@
+## 🤠 wrangler
+
+`wrangler` is a command line tool for building [Cloudflare Workers](https://workers.cloudflare.com/).
+
+[(Read the full stack week launch blog post.)](https://blog.cloudflare.com/wrangler-v2-beta/)
+
+**DISCLAIMER**: This is a work in progress, and is NOT recommended for use in production. We are opening this preview for feedback from the community, and to openly share our [roadmap](https://github.com/cloudflare/wrangler2/issues/12) for the future. As such, expect APIs and documentation to change before the end of the preview.
+
+Further, we will NOT do a general release until we are both feature complete, and have a full backward compatibility and incremental migration plan in place. For more details, follow the [parent roadmap issue](https://github.com/cloudflare/wrangler2/issues/12).
+
+## Quick Start
+
+```bash
+# Make a javascript file
+$ echo "export default { fetch() { return new Response('hello world') } }" > index.js
+# try it out
+$ npx wrangler@beta dev index.js
+# and then publish it
+$ npx wrangler@beta publish index.js --name my-worker
+# visit https://my-worker.<your workers subdomain>.workers.dev
+```
+
+## Installation:
+
+```bash
+$ npm install wrangler@beta
+```
+
+## Commands
+
+### `wrangler init [name]`
+
+Creates a `wrangler.toml` configuration file. For more details on the configuration keys and values, refer to the [documentation](https://developers.cloudflare.com/workers/cli-wrangler/configuration).
+
+### `wrangler dev [script]`
+
+Start a local development server, with live reloading and devtools.
+
+### `wrangler publish [script] --name [name]`
+
+Publish the given script to the worldwide Cloudflare network.
+
+For more commands and options, refer to the [documentation](https://developers.cloudflare.com/workers/cli-wrangler/commands).
+
+### `wrangler pages dev [directory] [-- command]`
+
+Either serves a static build asset directory, or proxies itself in front of a command.
+
+Builds and runs functions from a `./functions` directory or uses a `_worker.js` file inside the static build asset directory.
+
+For more commands and options, refer to the [documentation](https://developers.cloudflare.com/pages/platform/functions#develop-and-preview-locally) or run `wrangler pages dev --help`.

package/bin/wrangler.js

@@ -1,2 +1,36 @@
-#!/usr/bin/env node --no-warnings
-require("../wrangler-dist/index_node.js");
+#!/usr/bin/env node
+const { spawn } = require("child_process");
+const { join } = require("path");
+const semiver = require("semiver");
+
+const MIN_NODE_VERSION = "16.7.0";
+
+async function main() {
+  if (semiver(process.versions.node, MIN_NODE_VERSION) < 0) {
+    // Note Volta and nvm are also recommended in the official docs:
+    // https://developers.cloudflare.com/workers/get-started/guide#2-install-the-workers-cli
+    console.error(
+      `Wrangler requires at least Node.js v${MIN_NODE_VERSION}. You are using v${process.versions.node}.
+You should use the latest Node.js version if possible, as Cloudflare Workers use a very up-to-date version of V8.
+Consider using a Node.js version manager such as https://volta.sh/ or https://github.com/nvm-sh/nvm.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  spawn(
+    process.execPath,
+    [
+      "--no-warnings",
+      "--experimental-vm-modules",
+      ...process.execArgv,
+      join(__dirname, "../wrangler-dist/cli.js"),
+      ...process.argv.slice(2),
+    ],
+    { stdio: "inherit" }
+  ).on("exit", (code) =>
+    process.exit(code === undefined || code === null ? 0 : code)
+  );
+}
+
+void main();

package/import_meta_url.js

@@ -0,0 +1,3 @@
+// as per https://github.com/evanw/esbuild/issues/1492
+// to make some libs work
+export const import_meta_url = require("url").pathToFileURL(__filename);

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "wrangler",
-  "version": "0.0.0-efa548c",
+  "version": "0.0.0-fb43821",
   "author": "wrangler@cloudflare.com",
   "description": "Command-line interface for all things Cloudflare Workers",
-  "bin": "./bin/wrangler.js",
+  "bin": {
+    "wrangler": "./bin/wrangler.js",
+    "wrangler2": "./bin/wrangler.js"
+  },
   "license": "MIT OR Apache-2.0",
   "bugs": {
     "url": "https://github.com/cloudflare/wrangler/issues"
@@ -33,48 +36,79 @@
     "cli"
   ],
   "dependencies": {
-    "esbuild": "^0.12.19",
-    "miniflare": "^1.3.3",
-    "yargs": "^17.1.1"
+    "@cloudflare/pages-functions-compiler": "0.3.8",
+    "esbuild": "0.14.1",
+    "miniflare": "2.0.0-rc.4",
+    "semiver": "^1.1.0"
   },
   "optionalDependencies": {
     "fsevents": "~2.3.2"
   },
   "devDependencies": {
     "@iarna/toml": "^2.2.5",
-    "@types/cloudflare": "^2.7.6",
-    "@types/react": "^17.0.19",
+    "@types/react": "^17.0.37",
     "@types/signal-exit": "^3.0.1",
-    "@types/ws": "^7.4.7",
-    "@types/yargs": "^17.0.2",
-    "clipboardy": "^2.3.0",
-    "cloudflare": "^2.9.1",
-    "find-up": "^6.0.0",
-    "formdata-node": "^3.6.3",
+    "@types/ws": "^8.2.1",
+    "@types/yargs": "^17.0.7",
+    "chokidar": "^3.5.2",
+    "clipboardy": "^3.0.0",
+    "command-exists": "^1.2.9",
+    "execa": "^6.0.0",
+    "finalhandler": "^1.1.2",
+    "find-up": "^6.2.0",
+    "formdata-node": "^4.3.1",
     "http-proxy": "^1.18.1",
     "ink": "^3.2.0",
+    "ink-select-input": "^4.2.1",
     "ink-table": "^3.0.0",
-    "node-fetch": "github:tekwiz/node-fetch#fix/redirect-with-empty-chunked-transfer-encoding",
-    "open": "^8.2.1",
+    "ink-text-input": "^4.0.2",
+    "node-fetch": "^3.1.0",
+    "open": "^8.4.0",
+    "path-to-regexp": "^6.2.0",
     "react": "^17.0.2",
-    "signal-exit": "^3.0.5",
-    "tmp-promise": "^3.0.2",
-    "ws": "^8.2.0"
+    "react-error-boundary": "^3.1.4",
+    "serve-static": "^1.14.1",
+    "signal-exit": "^3.0.6",
+    "tmp-promise": "^3.0.3",
+    "undici": "^4.11.1",
+    "ws": "^8.3.0",
+    "yargs": "^17.3.0"
   },
   "files": [
+    "src",
     "bin",
     "miniflare-config-stubs",
     "wrangler-dist",
-    "facade.js",
-    "vendor"
+    "static-asset-facade.js",
+    "vendor",
+    "import_meta_url.js"
   ],
   "scripts": {
     "clean": "rm -rf wrangler-dist",
     "bundle": "node -r esbuild-register scripts/bundle.ts",
     "build": "npm run clean && npm run bundle",
-    "start": "npm run bundle && ./bin/wrangler.js"
+    "start": "npm run bundle && NODE_OPTIONS=--enable-source-maps ./bin/wrangler.js",
+    "test": "CF_API_TOKEN=some-api-token CF_ACCOUNT_ID=some-account-id jest --silent=false --verbose=true"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=16.7.0"
+  },
+  "jest": {
+    "restoreMocks": true,
+    "testRegex": ".*.(test|spec)\\.[jt]sx?$",
+    "transformIgnorePatterns": [
+      "node_modules/(?!node-fetch|fetch-blob|find-up|locate-path|p-locate|p-limit|yocto-queue|path-exists|data-uri-to-buffer|formdata-polyfill|execa|strip-final-newline|npm-run-path|path-key|onetime|mimic-fn|human-signals|is-stream)"
+    ],
+    "moduleNameMapper": {
+      "clipboardy": "<rootDir>/src/__tests__/clipboardy-mock.js"
+    },
+    "transform": {
+      "^.+\\.c?(t|j)sx?$": [
+        "esbuild-jest",
+        {
+          "sourcemap": true
+        }
+      ]
+    }
   }
 }

package/src/__tests__/clipboardy-mock.js

@@ -0,0 +1,4 @@
+// We use this mock during tests because we're having trouble
+// properly compiling clipboardy for jest
+// We can revisit this if and when we write tests that test
+// the copying part of `dev`

package/src/__tests__/index.test.ts

@@ -0,0 +1,422 @@
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as TOML from "@iarna/toml";
+import { main } from "../index";
+import { setMock, unsetAllMocks } from "./mock-cfetch";
+import { confirm } from "../dialogs";
+
+jest.mock("../cfetch", () => jest.requireActual("./mock-cfetch"));
+
+jest.mock("../dialogs", () => {
+  return {
+    ...jest.requireActual<object>("../dialogs"),
+    confirm: jest
+      .fn()
+      .mockName("confirmMock")
+      .mockImplementation(() => {
+        // By default (if not configured by mockConfirm()) calls to `confirm()` should throw.
+        throw new Error("Unexpected call to `confirm()`.");
+      }),
+  };
+});
+
+/**
+ * Mock the implementation of `confirm()` that will respond with configured results
+ * for configured confirmation text messages.
+ *
+ * If there is a call to `confirm()` that does not match any of the expectations
+ * then an error is thrown.
+ */
+function mockConfirm(...expectations: { text: string; result: boolean }[]) {
+  (confirm as jest.Mock).mockImplementation((text: string) => {
+    for (const { text: expectedText, result } of expectations) {
+      if (text === expectedText) {
+        return result;
+      }
+    }
+    throw new Error(`Unexpected confirmation message: ${text}`);
+  });
+}
+
+async function w(cmd?: string) {
+  const logSpy = jest.spyOn(console, "log").mockImplementation();
+  const errorSpy = jest.spyOn(console, "error").mockImplementation();
+  const warnSpy = jest.spyOn(console, "warn").mockImplementation();
+  try {
+    await main(cmd?.split(" ") ?? []);
+    return {
+      stdout: logSpy.mock.calls.flat(2).join("\n"),
+      stderr: errorSpy.mock.calls.flat(2).join("\n"),
+      warnings: warnSpy.mock.calls.flat(2).join("\n"),
+    };
+  } finally {
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    warnSpy.mockRestore();
+  }
+}
+
+describe("wrangler", () => {
+  describe("no command", () => {
+    it("should display a list of available commands", async () => {
+      const { stdout, stderr } = await w();
+
+      expect(stdout).toMatchInlineSnapshot(`
+        "wrangler
+
+        Commands:
+          wrangler init [name]       📥 Create a wrangler.toml configuration file
+          wrangler dev <filename>    👂 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 deployed Worker.
+          wrangler secret            🤫 Generate a secret that can be referenced in the worker script
+          wrangler kv:namespace      🗂️  Interact with your Workers KV Namespaces
+          wrangler kv:key            🔑 Individually manage Workers KV key-value pairs
+          wrangler kv:bulk           💪 Interact with multiple Workers KV key-value pairs at once
+          wrangler pages             ⚡️ Configure Cloudflare Pages
+
+        Flags:
+          -c, --config   Path to .toml configuration file  [string]
+          -h, --help     Show help  [boolean]
+          -v, --version  Show version number  [boolean]
+
+        Options:
+          -l, --local  Run on my machine  [boolean] [default: false]"
+      `);
+
+      expect(stderr).toMatchInlineSnapshot(`""`);
+    });
+  });
+
+  describe("invalid command", () => {
+    it("should display an error", async () => {
+      const { stdout, stderr } = await w("invalid-command");
+
+      expect(stdout).toMatchInlineSnapshot(`
+        "wrangler
+
+        Commands:
+          wrangler init [name]       📥 Create a wrangler.toml configuration file
+          wrangler dev <filename>    👂 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 deployed Worker.
+          wrangler secret            🤫 Generate a secret that can be referenced in the worker script
+          wrangler kv:namespace      🗂️  Interact with your Workers KV Namespaces
+          wrangler kv:key            🔑 Individually manage Workers KV key-value pairs
+          wrangler kv:bulk           💪 Interact with multiple Workers KV key-value pairs at once
+          wrangler pages             ⚡️ Configure Cloudflare Pages
+
+        Flags:
+          -c, --config   Path to .toml configuration file  [string]
+          -h, --help     Show help  [boolean]
+          -v, --version  Show version number  [boolean]
+
+        Options:
+          -l, --local  Run on my machine  [boolean] [default: false]"
+      `);
+
+      expect(stderr).toMatchInlineSnapshot(`
+        "
+        Unknown command: invalid-command."
+      `);
+    });
+  });
+
+  describe("init", () => {
+    const ogcwd = process.cwd();
+    let tmpDir: string;
+
+    beforeEach(async () => {
+      tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), "init-"));
+      process.chdir(tmpDir);
+    });
+
+    afterEach(async () => {
+      process.chdir(ogcwd);
+      await fsp.rm(tmpDir, { recursive: true });
+    });
+
+    it("should create a wrangler.toml", async () => {
+      mockConfirm({
+        text: "No package.json found. Would you like to create one?",
+        result: false,
+      });
+      await w("init");
+      const parsed = TOML.parse(await fsp.readFile("./wrangler.toml", "utf-8"));
+      expect(typeof parsed.compatibility_date).toBe("string");
+      expect(fs.existsSync("./package.json")).toBe(false);
+      expect(fs.existsSync("./tsconfig.json")).toBe(false);
+    });
+
+    it("should display warning when wrangler.toml already exists, and exit if user does not want to carry on", async () => {
+      fs.closeSync(fs.openSync("./wrangler.toml", "w"));
+      mockConfirm({
+        text: "Do you want to continue initializing this project?",
+        result: false,
+      });
+      const { stderr } = await w("init");
+      expect(stderr).toContain("wrangler.toml file already exists!");
+      const parsed = TOML.parse(await fsp.readFile("./wrangler.toml", "utf-8"));
+      expect(typeof parsed.compatibility_date).toBe("undefined");
+    });
+
+    it("should display warning when wrangler.toml already exists, but continue if user does want to carry on", async () => {
+      fs.closeSync(fs.openSync("./wrangler.toml", "w"));
+      mockConfirm(
+        {
+          text: "Do you want to continue initializing this project?",
+          result: true,
+        },
+        {
+          text: "No package.json found. Would you like to create one?",
+          result: false,
+        }
+      );
+      const { stderr } = await w("init");
+      expect(stderr).toContain("wrangler.toml file already exists!");
+      const parsed = TOML.parse(await fsp.readFile("./wrangler.toml", "utf-8"));
+      expect(typeof parsed.compatibility_date).toBe("string");
+    });
+
+    it("should create a package.json if none is found and user confirms", async () => {
+      mockConfirm(
+        {
+          text: "No package.json found. Would you like to create one?",
+          result: true,
+        },
+        {
+          text: "Would you like to use typescript?",
+          result: false,
+        }
+      );
+      await w("init");
+      expect(fs.existsSync("./package.json")).toBe(true);
+      const packageJson = JSON.parse(
+        fs.readFileSync("./package.json", "utf-8")
+      );
+      expect(packageJson.name).toEqual("worker"); // TODO: should we infer the name from the directory?
+      expect(packageJson.version).toEqual("0.0.1");
+      expect(fs.existsSync("./tsconfig.json")).toBe(false);
+    });
+
+    it("should not touch an existing package.json in the same directory", async () => {
+      mockConfirm({
+        text: "Would you like to use typescript?",
+        result: false,
+      });
+
+      fs.writeFileSync(
+        "./package.json",
+        JSON.stringify({ name: "test", version: "1.0.0" }),
+        "utf-8"
+      );
+
+      await w("init");
+      const packageJson = JSON.parse(
+        fs.readFileSync("./package.json", "utf-8")
+      );
+      expect(packageJson.name).toEqual("test");
+      expect(packageJson.version).toEqual("1.0.0");
+    });
+
+    it("should not touch an existing package.json in an ancestor directory", async () => {
+      mockConfirm({
+        text: "Would you like to use typescript?",
+        result: false,
+      });
+
+      fs.writeFileSync(
+        "./package.json",
+        JSON.stringify({ name: "test", version: "1.0.0" }),
+        "utf-8"
+      );
+
+      fs.mkdirSync("./sub-1/sub-2", { recursive: true });
+      process.chdir("./sub-1/sub-2");
+
+      await w("init");
+      expect(fs.existsSync("./package.json")).toBe(false);
+      expect(fs.existsSync("../../package.json")).toBe(true);
+
+      const packageJson = JSON.parse(
+        fs.readFileSync("../../package.json", "utf-8")
+      );
+      expect(packageJson.name).toEqual("test");
+      expect(packageJson.version).toEqual("1.0.0");
+    });
+
+    it("should create a tsconfig.json and install `workers-types` if none is found and user confirms", async () => {
+      mockConfirm(
+        {
+          text: "No package.json found. Would you like to create one?",
+          result: true,
+        },
+        {
+          text: "Would you like to use typescript?",
+          result: true,
+        }
+      );
+      await w("init");
+      expect(fs.existsSync("./tsconfig.json")).toBe(true);
+      const tsconfigJson = JSON.parse(
+        fs.readFileSync("./tsconfig.json", "utf-8")
+      );
+      expect(tsconfigJson.compilerOptions.types).toEqual([
+        "@cloudflare/workers-types",
+      ]);
+      const packageJson = JSON.parse(
+        fs.readFileSync("./package.json", "utf-8")
+      );
+      expect(packageJson.devDependencies).toEqual({
+        "@cloudflare/workers-types": expect.any(String),
+      });
+    });
+
+    it("should not touch an existing tsconfig.json in the same directory", async () => {
+      fs.writeFileSync(
+        "./package.json",
+        JSON.stringify({ name: "test", version: "1.0.0" }),
+        "utf-8"
+      );
+      fs.writeFileSync(
+        "./tsconfig.json",
+        JSON.stringify({ compilerOptions: {} }),
+        "utf-8"
+      );
+
+      await w("init");
+      const tsconfigJson = JSON.parse(
+        fs.readFileSync("./tsconfig.json", "utf-8")
+      );
+      expect(tsconfigJson.compilerOptions).toEqual({});
+    });
+
+    it("should not touch an existing package.json in an ancestor directory", async () => {
+      fs.writeFileSync(
+        "./package.json",
+        JSON.stringify({ name: "test", version: "1.0.0" }),
+        "utf-8"
+      );
+      fs.writeFileSync(
+        "./tsconfig.json",
+        JSON.stringify({ compilerOptions: {} }),
+        "utf-8"
+      );
+
+      fs.mkdirSync("./sub-1/sub-2", { recursive: true });
+      process.chdir("./sub-1/sub-2");
+
+      await w("init");
+      expect(fs.existsSync("./tsconfig.json")).toBe(false);
+      expect(fs.existsSync("../../tsconfig.json")).toBe(true);
+
+      const tsconfigJson = JSON.parse(
+        fs.readFileSync("../../tsconfig.json", "utf-8")
+      );
+      expect(tsconfigJson.compilerOptions).toEqual({});
+    });
+
+    it("should error if `--type` is used", async () => {
+      const noValue = await w("init --type");
+      expect(noValue.stderr).toMatchInlineSnapshot(
+        `"The --type option is no longer supported."`
+      );
+    });
+
+    it("should error if `--type javascript` is used", async () => {
+      const javascriptValue = await w("init --type javascript");
+      expect(javascriptValue.stderr).toMatchInlineSnapshot(
+        `"The --type option is no longer supported."`
+      );
+    });
+
+    it("should error if `--type rust` is used", async () => {
+      const rustValue = await w("init --type rust");
+      expect(rustValue.stderr).toMatchInlineSnapshot(
+        `"The --type option is no longer supported."`
+      );
+    });
+
+    it("should error if `--type webpack` is used", async () => {
+      const webpackValue = await w("init --type webpack");
+      expect(webpackValue.stderr).toMatchInlineSnapshot(`
+        "The --type option is no longer supported.
+        If you wish to use webpack then you will need to create a custom build."
+      `);
+    });
+  });
+
+  describe("kv:namespace", () => {
+    afterEach(() => {
+      unsetAllMocks();
+    });
+
+    it("can create a namespace", async () => {
+      const KVNamespaces: { title: string; id: string }[] = [];
+      setMock("/accounts/:accountId/storage/kv/namespaces", (uri, init) => {
+        expect(init.method === "POST");
+        expect(uri[0]).toEqual(
+          "/accounts/some-account-id/storage/kv/namespaces"
+        );
+        const { title } = JSON.parse(init.body);
+        expect(title).toEqual("worker-UnitTestNamespace");
+        KVNamespaces.push({ title, id: "some-namespace-id" });
+        return { id: "some-namespace-id" };
+      });
+
+      await w("kv:namespace create UnitTestNamespace");
+
+      expect(KVNamespaces).toEqual([
+        {
+          title: "worker-UnitTestNamespace",
+          id: "some-namespace-id",
+        },
+      ]);
+    });
+
+    it("can list namespaces", async () => {
+      const KVNamespaces: { title: string; id: string }[] = [
+        { title: "title-1", id: "id-1" },
+        { title: "title-2", id: "id-2" },
+      ];
+      setMock(
+        "/accounts/:accountId/storage/kv/namespaces\\?:qs",
+        (uri, init) => {
+          expect(uri[0]).toContain(
+            "/accounts/some-account-id/storage/kv/namespaces"
+          );
+          expect(uri[2]).toContain("per_page=100");
+          expect(uri[2]).toContain("order=title");
+          expect(uri[2]).toContain("direction=asc");
+          expect(uri[2]).toContain("page=1");
+          expect(init).toBe(undefined);
+          return KVNamespaces;
+        }
+      );
+      const { stdout } = await w("kv:namespace list");
+      const namespaces = JSON.parse(stdout) as { id: string; title: string }[];
+      expect(namespaces).toEqual(KVNamespaces);
+    });
+
+    it("can delete a namespace", async () => {
+      let accountId = "";
+      let namespaceId = "";
+      setMock(
+        "/accounts/:accountId/storage/kv/namespaces/:namespaceId",
+        (uri, init) => {
+          accountId = uri[1];
+          namespaceId = uri[2];
+          expect(uri[0]).toEqual(
+            "/accounts/some-account-id/storage/kv/namespaces/some-namespace-id"
+          );
+          expect(init.method).toBe("DELETE");
+        }
+      );
+      await w(`kv:namespace delete --namespace-id some-namespace-id`);
+      expect(accountId).toEqual("some-account-id");
+      expect(namespaceId).toEqual("some-namespace-id");
+    });
+  });
+});

package/src/__tests__/mock-cfetch.js

@@ -0,0 +1,42 @@
+// This file mocks ../cfetch.ts
+// so we can insert whatever responses we want from it
+
+const { pathToRegexp } = require("path-to-regexp");
+// TODO: add jsdoc style types here
+
+// type MockHandler = (resource: string, init?: RequestInit) => any; // TODO: use a generic here
+
+let mocks = [];
+
+export function mockCfetch(resource, init) {
+  for (const { regexp, handler } of mocks) {
+    // The `resource` regular expression will extract the labelled groups from the URL.
+    // Let's pass these through to the handler, to allow it to do additional checks or behaviour.
+    const uri = regexp.exec(resource);
+    if (uri !== null) {
+      return handler(uri, init); // TODO: should we have some kind of fallthrough system? we'll see.
+    }
+  }
+  throw new Error(`no mocks found for ${resource}`);
+}
+
+export function setMock(resource, handler) {
+  const mock = {
+    resource,
+    handler,
+    regexp: pathToRegexp(resource),
+  };
+  mocks.push(mock);
+  return () => {
+    mocks = mocks.filter((x) => x !== mock);
+  };
+}
+
+export function unsetAllMocks() {
+  mocks = [];
+}
+
+export const CF_API_BASE_URL =
+  process.env.CF_API_BASE_URL || "https://api.cloudflare.com/client/v4";
+
+export default mockCfetch;