wrangler 0.0.2 → 0.0.6

package/src/__tests__/index.test.ts

@@ -0,0 +1,391 @@
+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 { mockConfirm } from "./mock-dialogs";
+
+jest.mock("../cfetch", () => jest.requireActual("./mock-cfetch"));
+
+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__/jest.setup.ts

@@ -0,0 +1,17 @@
+import { confirm, prompt } from "../dialogs";
+
+jest.mock("../dialogs");
+
+// By default (if not configured by mockConfirm()) calls to `confirm()` should throw.
+(confirm as jest.Mock).mockImplementation(() => {
+  throw new Error(
+    "Unexpected call to `confirm()`. You should use `mockConfirm()` to mock calls to `confirm()` with expectations. Search the codebase for `mockConfirm` to learn more."
+  );
+});
+
+// By default (if not configured by mockPrompt()) calls to `prompt()` should throw.
+(prompt as jest.Mock).mockImplementation(() => {
+  throw new Error(
+    "Unexpected call to `prompt()`. You should use `mockPrompt()` to mock calls to `prompt()` with expectations. Search the codebase for `mockPrompt` to learn more."
+  );
+});

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;

package/src/__tests__/mock-dialogs.ts

@@ -0,0 +1,65 @@
+import { confirm, prompt } from "../dialogs";
+
+/**
+ * The expected values for a confirmation request.
+ */
+export interface ConfirmExpectation {
+  /** The text expected to be seen in the confirmation dialog. */
+  text: string;
+  /** The mock response send back from the confirmation dialog. */
+  result: boolean;
+}
+
+/**
+ * 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.
+ */
+export function mockConfirm(...expectations: ConfirmExpectation[]) {
+  (confirm as jest.Mock).mockImplementation((text: string) => {
+    for (const { text: expectedText, result } of expectations) {
+      if (text === expectedText) {
+        return Promise.resolve(result);
+      }
+    }
+    throw new Error(`Unexpected confirmation message: ${text}`);
+  });
+}
+
+/**
+ * The expected values for a prompt request.
+ */
+export interface PromptExpectation {
+  /** The text expected to be seen in the prompt dialog. */
+  text: string;
+  /** The type of the prompt. */
+  type: "text" | "password";
+  /** The mock response send back from the prompt dialog. */
+  result: string;
+}
+
+/**
+ * Mock the implementation of `prompt()` that will respond with configured results
+ * for configured prompt text messages.
+ *
+ * If there is a call to `prompt()` that does not match any of the expectations
+ * then an error is thrown.
+ */
+export function mockPrompt(...expectations: PromptExpectation[]) {
+  (prompt as jest.Mock).mockImplementation(
+    (text: string, type: "text" | "password") => {
+      for (const {
+        text: expectedText,
+        type: expectedType,
+        result,
+      } of expectations) {
+        if (text === expectedText && type == expectedType) {
+          return Promise.resolve(result);
+        }
+      }
+      throw new Error(`Unexpected confirmation message: ${text}`);
+    }
+  );
+}

package/src/api/form_data.ts

@@ -0,0 +1,141 @@
+import type {
+  CfWorkerInit,
+  CfModuleType,
+  CfVariable,
+  CfModule,
+} from "./worker.js";
+import { FormData, Blob } from "formdata-node";
+
+// Credit: https://stackoverflow.com/a/9458996
+function toBase64(source: BufferSource): string {
+  let result = "";
+  const buffer = source instanceof ArrayBuffer ? source : source.buffer;
+  const bytes = new Uint8Array(buffer);
+  for (let i = 0; i < bytes.byteLength; i++) {
+    result += String.fromCharCode(bytes[i]);
+  }
+  return btoa(result);
+}
+
+function toBinding(
+  name: string,
+  variable: CfVariable
+): Record<string, unknown> {
+  if (typeof variable === "string") {
+    return { name, type: "plain_text", text: variable };
+  }
+
+  if ("namespaceId" in variable) {
+    return {
+      name,
+      type: "kv_namespace",
+      namespace_id: variable.namespaceId,
+    };
+  }
+
+  if ("class_name" in variable) {
+    return {
+      name,
+      type: "durable_object_namespace",
+      class_name: variable.class_name,
+      ...(variable.script_name && {
+        script_name: variable.script_name,
+      }),
+    };
+  }
+
+  const { format, algorithm, usages, data } = variable;
+  if (format) {
+    let key_base64;
+    let key_jwk;
+    if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+      key_base64 = toBase64(data);
+    } else {
+      key_jwk = data;
+    }
+    return {
+      name,
+      type: "secret_key",
+      format,
+      algorithm,
+      usages,
+      key_base64,
+      key_jwk,
+    };
+  }
+
+  throw new TypeError("Unsupported variable: " + variable);
+}
+
+export function toMimeType(type: CfModuleType): string {
+  switch (type) {
+    case "esm":
+      return "application/javascript+module";
+    case "commonjs":
+      return "application/javascript";
+    case "compiled-wasm":
+      return "application/wasm";
+    case "buffer":
+      return "application/octet-stream";
+    case "text":
+      return "text/plain";
+    default:
+      throw new TypeError("Unsupported module: " + type);
+  }
+}
+
+function toModule(module: CfModule, entryType?: CfModuleType): Blob {
+  const { type: moduleType, content } = module;
+  const type = toMimeType(moduleType ?? entryType);
+
+  return new Blob([content], { type });
+}
+
+/**
+ * Creates a `FormData` upload from a `CfWorkerInit`.
+ */
+export function toFormData(worker: CfWorkerInit): FormData {
+  const formData = new FormData();
+  const {
+    main,
+    modules,
+    variables,
+    migrations,
+    usage_model,
+    compatibility_date,
+    compatibility_flags,
+  } = worker;
+  const { name, type: mainType } = main;
+
+  const bindings = [];
+  for (const [name, variable] of Object.entries(variables ?? {})) {
+    const binding = toBinding(name, variable);
+    bindings.push(binding);
+  }
+
+  // TODO: this object should be typed
+  const metadata = {
+    ...(mainType !== "commonjs" ? { main_module: name } : { body_part: name }),
+    bindings,
+    ...(compatibility_date && { compatibility_date }),
+    ...(compatibility_flags && { compatibility_flags }),
+    ...(usage_model && { usage_model }),
+    ...(migrations && { migrations }),
+  };
+
+  formData.set("metadata", JSON.stringify(metadata));
+
+  if (mainType === "commonjs" && modules && modules.length > 0) {
+    throw new TypeError(
+      "More than one module can only be specified when type = 'esm'"
+    );
+  }
+
+  for (const module of [main].concat(modules || [])) {
+    const { name } = module;
+    const blob = toModule(module, mainType ?? "esm");
+    formData.set(name, blob, name);
+  }
+
+  return formData;
+}