wrangler 0.0.0-e4e9eaf → 0.0.0-e9a1820

package/src/__tests__/kv.test.ts

@@ -0,0 +1,322 @@
+import { setMock, unsetAllMocks } from "./mock-cfetch";
+import { runWrangler } from "./run-wrangler";
+import { runInTempDir } from "./run-in-tmp";
+import { writeFileSync } from "fs";
+
+describe("wrangler", () => {
+  runInTempDir();
+
+  afterEach(() => {
+    unsetAllMocks();
+  });
+
+  describe("kv:namespace", () => {
+    describe("create", () => {
+      function mockCreateRequest(expectedTitle: string) {
+        setMock(
+          "/accounts/:accountId/storage/kv/namespaces",
+          "POST",
+          ([_url, accountId], { body }) => {
+            expect(accountId).toEqual("some-account-id");
+            const title = JSON.parse(body).title;
+            expect(title).toEqual(expectedTitle);
+            return { id: "some-namespace-id" };
+          }
+        );
+      }
+
+      it("should error if no namespace is given", async () => {
+        const { error, stdout, stderr } = await runWrangler(
+          "kv:namespace create"
+        );
+        expect(stdout).toMatchInlineSnapshot(`""`);
+        expect(stderr).toMatchInlineSnapshot(`
+          "wrangler kv:namespace create <namespace>
+
+          Create a new namespace
+
+          Positionals:
+            namespace  The name of the new namespace  [string] [required]
+
+          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]
+                --env      Perform on a specific environment  [string]
+                --preview  Interact with a preview namespace  [boolean]
+
+          Not enough non-option arguments: got 0, need at least 1"
+        `);
+        expect(error).toMatchInlineSnapshot(
+          `[Error: Not enough non-option arguments: got 0, need at least 1]`
+        );
+      });
+
+      it("should error if the namespace to create contains spaces", async () => {
+        const { error, stdout, stderr } = await runWrangler(
+          "kv:namespace create abc def ghi"
+        );
+        expect(stdout).toMatchInlineSnapshot(`""`);
+        expect(stderr).toMatchInlineSnapshot(`
+          "wrangler kv:namespace create <namespace>
+
+          Create a new namespace
+
+          Positionals:
+            namespace  The name of the new namespace  [string] [required]
+
+          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]
+                --env      Perform on a specific environment  [string]
+                --preview  Interact with a preview namespace  [boolean]
+
+          Unexpected additional positional arguments \\"def ghi\\"."
+        `);
+        expect(error).toMatchInlineSnapshot(
+          `[Error: Unexpected additional positional arguments "def ghi".]`
+        );
+      });
+
+      it("should error if the namespace to create is not valid", async () => {
+        const { error, stdout, stderr } = await runWrangler(
+          "kv:namespace create abc-def"
+        );
+        expect(stdout).toMatchInlineSnapshot(`""`);
+        expect(stderr).toMatchInlineSnapshot(`
+          "wrangler kv:namespace create <namespace>
+
+          Create a new namespace
+
+          Positionals:
+            namespace  The name of the new namespace  [string] [required]
+
+          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]
+                --env      Perform on a specific environment  [string]
+                --preview  Interact with a preview namespace  [boolean]
+
+          The namespace binding name \\"abc-def\\" is invalid. It can only have alphanumeric and _ characters, and cannot begin with a number."
+        `);
+        expect(error).toMatchInlineSnapshot(
+          `[Error: The namespace binding name "abc-def" is invalid. It can only have alphanumeric and _ characters, and cannot begin with a number.]`
+        );
+      });
+
+      it("should create a namespace", async () => {
+        mockCreateRequest("worker-UnitTestNamespace");
+        const { stdout } = await runWrangler(
+          "kv:namespace create UnitTestNamespace"
+        );
+        expect(stdout).toMatchInlineSnapshot(`
+          "🌀 Creating namespace with title \\"worker-UnitTestNamespace\\"
+          ✨ Success!
+          Add the following to your configuration file in your kv_namespaces array:
+          { binding = \\"UnitTestNamespace\\", id = \\"some-namespace-id\\" }"
+        `);
+      });
+
+      it("should create a preview namespace if configured to do so", async () => {
+        mockCreateRequest("worker-UnitTestNamespace_preview");
+        const { stdout } = await runWrangler(
+          "kv:namespace create UnitTestNamespace --preview"
+        );
+        expect(stdout).toMatchInlineSnapshot(`
+          "🌀 Creating namespace with title \\"worker-UnitTestNamespace_preview\\"
+          ✨ Success!
+          Add the following to your configuration file in your kv_namespaces array:
+          { binding = \\"UnitTestNamespace\\", preview_id = \\"some-namespace-id\\" }"
+        `);
+      });
+
+      it("should create a namespace using configured worker name", async () => {
+        writeFileSync("./wrangler.toml", 'name = "otherWorker"', "utf-8");
+        mockCreateRequest("otherWorker-UnitTestNamespace");
+        const { stdout } = await runWrangler(
+          "kv:namespace create UnitTestNamespace"
+        );
+        expect(stdout).toMatchInlineSnapshot(`
+            "🌀 Creating namespace with title \\"otherWorker-UnitTestNamespace\\"
+            ✨ Success!
+            Add the following to your configuration file in your kv_namespaces array:
+            { binding = \\"UnitTestNamespace\\", id = \\"some-namespace-id\\" }"
+            `);
+      });
+
+      it("should create a namespace in an environment if configured to do so", async () => {
+        mockCreateRequest("worker-customEnv-UnitTestNamespace");
+        const { stdout } = await runWrangler(
+          "kv:namespace create UnitTestNamespace --env customEnv"
+        );
+        expect(stdout).toMatchInlineSnapshot(`
+          "🌀 Creating namespace with title \\"worker-customEnv-UnitTestNamespace\\"
+          ✨ Success!
+          Add the following to your configuration file in your kv_namespaces array under [env.customEnv]:
+          { binding = \\"UnitTestNamespace\\", id = \\"some-namespace-id\\" }"
+        `);
+      });
+    });
+
+    describe("list", () => {
+      function mockListRequest(namespaces: unknown[]) {
+        const requests = { count: 0 };
+        setMock(
+          "/accounts/:accountId/storage/kv/namespaces\\?:qs",
+          ([_url, accountId, query], init) => {
+            requests.count++;
+            expect(accountId).toEqual("some-account-id");
+            expect(query).toContain("per_page=100");
+            expect(query).toContain("order=title");
+            expect(query).toContain("direction=asc");
+            expect(query).toContain("page=");
+            expect(init).toBe(undefined);
+            const pageSize = Number(/\bper_page=(\d+)\b/.exec(query)[1]);
+            const page = Number(/\bpage=(\d+)/.exec(query)[1]);
+            return namespaces.slice((page - 1) * pageSize, page * pageSize);
+          }
+        );
+        return requests;
+      }
+
+      it("should list namespaces", async () => {
+        const KVNamespaces = [
+          { title: "title-1", id: "id-1" },
+          { title: "title-2", id: "id-2" },
+        ];
+        mockListRequest(KVNamespaces);
+        const { stdout } = await runWrangler("kv:namespace list");
+        const namespaces = JSON.parse(stdout);
+        expect(namespaces).toEqual(KVNamespaces);
+      });
+
+      it("should make multiple requests for paginated results", async () => {
+        // Create a lot of mock namespaces, so that the cfetch requests will be paginated
+        const KVNamespaces = [];
+        for (let i = 0; i < 550; i++) {
+          KVNamespaces.push({ title: "title-" + i, id: "id-" + i });
+        }
+        const requests = mockListRequest(KVNamespaces);
+        const { stdout } = await runWrangler("kv:namespace list");
+        const namespaces = JSON.parse(stdout);
+        expect(namespaces).toEqual(KVNamespaces);
+        expect(requests.count).toEqual(6);
+      });
+    });
+
+    describe("delete", () => {
+      function mockDeleteRequest(expectedNamespaceId: string) {
+        const requests = { count: 0 };
+        setMock(
+          "/accounts/:accountId/storage/kv/namespaces/:namespaceId",
+          "DELETE",
+          ([_url, accountId, namespaceId]) => {
+            requests.count++;
+            expect(accountId).toEqual("some-account-id");
+            expect(namespaceId).toEqual(expectedNamespaceId);
+            return null;
+          }
+        );
+        return requests;
+      }
+
+      function writeWranglerConfig() {
+        writeFileSync(
+          "./wrangler.toml",
+          [
+            'name = "otherWorker"',
+            "kv_namespaces = [",
+            '  { binding = "someBinding", id = "bound-id", preview_id = "preview-bound-id" }',
+            "]",
+            "",
+            "[env.some-environment]",
+            "kv_namespaces = [",
+            '  { binding = "someBinding", id = "env-bound-id", preview_id = "preview-env-bound-id" }',
+            "]",
+          ].join("\n"),
+          "utf-8"
+        );
+      }
+
+      it("should delete a namespace specified by id", async () => {
+        const requests = mockDeleteRequest("some-namespace-id");
+        await runWrangler(
+          `kv:namespace delete --namespace-id some-namespace-id`
+        );
+        expect(requests.count).toEqual(1);
+      });
+
+      it("should delete a namespace specified by binding name", async () => {
+        writeWranglerConfig();
+        const requests = mockDeleteRequest("bound-id");
+        await runWrangler(`kv:namespace delete --binding someBinding`);
+        expect(requests.count).toEqual(1);
+      });
+
+      it("should delete a preview namespace specified by binding name", async () => {
+        writeWranglerConfig();
+        const requests = mockDeleteRequest("preview-bound-id");
+        await runWrangler(
+          `kv:namespace delete --binding someBinding --preview`
+        );
+        expect(requests.count).toEqual(1);
+      });
+
+      it("should error if a given binding name is not in the configured kv namespaces", async () => {
+        writeWranglerConfig();
+        const { stderr } = await runWrangler(
+          `kv:namespace delete --binding otherBinding`
+        );
+        expect(stderr).toMatchInlineSnapshot(`
+          "wrangler kv:namespace delete
+
+          Deletes a given namespace.
+
+          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]
+                --binding       The name of the namespace to delete  [string]
+                --namespace-id  The id of the namespace to delete  [string]
+                --env           Perform on a specific environment  [string]
+                --preview       Interact with a preview namespace  [boolean]
+
+          Not able to delete namespace.
+          A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\"."
+        `);
+      });
+
+      it("should delete a namespace specified by binding name in a given environment", async () => {
+        writeWranglerConfig();
+        const requests = mockDeleteRequest("env-bound-id");
+        await runWrangler(
+          `kv:namespace delete --binding someBinding --env some-environment`
+        );
+        expect(requests.count).toEqual(1);
+      });
+
+      it("should delete a preview namespace specified by binding name in a given environment", async () => {
+        writeWranglerConfig();
+        const requests = mockDeleteRequest("preview-env-bound-id");
+        await runWrangler(
+          `kv:namespace delete --binding someBinding --env some-environment --preview`
+        );
+        expect(requests.count).toEqual(1);
+      });
+    });
+  });
+});

package/src/__tests__/mock-cfetch.ts

@@ -0,0 +1,63 @@
+// This file mocks ../cfetch.ts
+// so we can insert whatever responses we want from it
+import { pathToRegexp } from "path-to-regexp";
+
+// Sadly we cannot give use the correct `RequestInit` type from node-fetch.
+// Jest needs to transform the code as part of the module mocking, and it doesn't know how to cope with such types.
+type RequestInit = { method: string; body: string };
+type MockHandler = (uri: RegExpExecArray, init?: RequestInit) => unknown;
+type MockFetch = {
+  regexp: RegExp;
+  method: string | undefined;
+  handler: MockHandler;
+};
+type RemoveMockFn = () => void;
+
+let mocks: MockFetch[] = [];
+
+export default function mockCfetch(
+  resource: string,
+  init: RequestInit
+): unknown {
+  for (const { regexp, method, handler } of mocks) {
+    const uri = regexp.exec(resource);
+    // Do the resource path and (if specified) the HTTP method match?
+    if (uri !== null && (!method || method === init.method)) {
+      // The `resource` regular expression will extract the labelled groups from the URL.
+      // These are passed through to the `handler` call, to allow it to do additional checks or behaviour.
+      return handler(uri, init); // TODO: should we have some kind of fallthrough system? we'll see.
+    }
+  }
+  throw new Error(`no mocks found for ${resource}`);
+}
+
+/**
+ * Specify an expected resource path that is to be handled.
+ */
+export function setMock(
+  resource: string,
+  method: string,
+  handler: MockHandler
+): RemoveMockFn;
+export function setMock(resource: string, handler: MockHandler): RemoveMockFn;
+export function setMock(resource: string, ...args: unknown[]): RemoveMockFn {
+  const handler = args.pop() as MockHandler;
+  const method = args.pop() as string;
+  const mock = {
+    resource,
+    method,
+    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";

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/__tests__/run-in-tmp.ts

@@ -0,0 +1,19 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import * as fs from "fs";
+
+const originalCwd = process.cwd();
+
+export function runInTempDir() {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wrangler-tests"));
+    process.chdir(tmpDir);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+}

package/src/__tests__/run-wrangler.ts

@@ -0,0 +1,32 @@
+import { main } from "../index";
+
+/**
+ * Run the wrangler CLI tool in tests, capturing the logging output.
+ */
+export async function runWrangler(cmd?: string) {
+  const logSpy = jest.spyOn(console, "log").mockImplementation();
+  const errorSpy = jest.spyOn(console, "error").mockImplementation();
+  const warnSpy = jest.spyOn(console, "warn").mockImplementation();
+  try {
+    let error: unknown = undefined;
+    try {
+      await main(cmd?.split(" ") ?? []);
+    } catch (e) {
+      error = e;
+    }
+    return {
+      error,
+      stdout: captureCalls(logSpy),
+      stderr: captureCalls(errorSpy),
+      warnings: captureCalls(warnSpy),
+    };
+  } finally {
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    warnSpy.mockRestore();
+  }
+}
+
+function captureCalls(spy: jest.SpyInstance): string {
+  return spy.mock.calls.flat(2).join("\n");
+}

package/src/api/form_data.ts

@@ -0,0 +1,131 @@
+import type {
+  CfWorkerInit,
+  CfModuleType,
+  CfModule,
+  CfDurableObjectMigrations,
+} from "./worker.js";
+import { FormData, Blob } from "formdata-node";
+
+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 });
+}
+
+interface WorkerMetadata {
+  compatibility_date?: string;
+  compatibility_flags?: string[];
+  usage_model?: "bundled" | "unbound";
+  migrations?: CfDurableObjectMigrations;
+  bindings: (
+    | { type: "kv_namespace"; name: string; namespace_id: string }
+    | { type: "plain_text"; name: string; text: string }
+    | {
+        type: "durable_object_namespace";
+        name: string;
+        class_name: string;
+        script_name?: string;
+      }
+    | {
+        type: "service";
+        name: string;
+        service: string;
+        environment: string;
+      }
+  )[];
+}
+
+/**
+ * Creates a `FormData` upload from a `CfWorkerInit`.
+ */
+export function toFormData(worker: CfWorkerInit): FormData {
+  const formData = new FormData();
+  const {
+    main,
+    modules,
+    bindings,
+    migrations,
+    usage_model,
+    compatibility_date,
+    compatibility_flags,
+  } = worker;
+
+  const metadataBindings: WorkerMetadata["bindings"] = [];
+
+  bindings.kv_namespaces?.forEach(({ id, binding }) => {
+    metadataBindings.push({
+      name: binding,
+      type: "kv_namespace",
+      namespace_id: id,
+    });
+  });
+
+  bindings.durable_objects?.bindings.forEach(
+    ({ name, class_name, script_name }) => {
+      metadataBindings.push({
+        name,
+        type: "durable_object_namespace",
+        class_name: class_name,
+        ...(script_name && { script_name }),
+      });
+    }
+  );
+
+  Object.entries(bindings.vars || {})?.forEach(([key, value]) => {
+    metadataBindings.push({ name: key, type: "plain_text", text: value });
+  });
+
+  bindings.services?.forEach(({ name, service, environment }) => {
+    metadataBindings.push({
+      name,
+      type: "service",
+      service,
+      environment,
+    });
+  });
+
+  const metadata: WorkerMetadata = {
+    ...(main.type !== "commonjs"
+      ? { main_module: main.name }
+      : { body_part: main.name }),
+    bindings: metadataBindings,
+    ...(compatibility_date && { compatibility_date }),
+    ...(compatibility_flags && { compatibility_flags }),
+    ...(usage_model && { usage_model }),
+    ...(migrations && { migrations }),
+  };
+
+  formData.set("metadata", JSON.stringify(metadata));
+
+  if (main.type === "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, main.type ?? "esm");
+    formData.set(name, blob, name);
+  }
+
+  return formData;
+}