wrangler 0.0.0-ece06ea → 0.0.0-ef13735

package/src/__tests__/secret.test.ts

@@ -0,0 +1,210 @@
+import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
+import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { mockConfirm, mockPrompt } from "./helpers/mock-dialogs";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+
+describe("wrangler secret", () => {
+  const std = mockConsoleMethods();
+  runInTempDir();
+  mockAccountId();
+  mockApiToken();
+
+  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

@@ -0,0 +1,86 @@
+import { render } from "ink-testing-library";
+import React from "react";
+import { initialise } from "../user";
+import { getUserInfo, WhoAmI } from "../whoami";
+import { setMockResponse } from "./helpers/mock-cfetch";
+import { writeUserConfig } from "./helpers/mock-user";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import type { UserInfo } from "../whoami";
+
+describe("getUserInfo()", () => {
+  runInTempDir({ homedir: "./home" });
+
+  it("should return undefined if there is no config file", async () => {
+    await initialise();
+    const userInfo = await getUserInfo();
+    expect(userInfo).toBeUndefined();
+  });
+
+  it("should return undefined if there is an empty config file", async () => {
+    writeUserConfig();
+    await initialise();
+    const userInfo = await getUserInfo();
+    expect(userInfo).toBeUndefined();
+  });
+
+  it("should return the user's email and accounts if authenticated via config token", async () => {
+    writeUserConfig("some-oauth-token");
+    setMockResponse("/user", () => {
+      return { email: "user@example.com" };
+    });
+    setMockResponse("/accounts", () => {
+      return [
+        { name: "Account One", id: "account-1" },
+        { name: "Account Two", id: "account-2" },
+        { name: "Account Three", id: "account-3" },
+      ];
+    });
+
+    await initialise();
+    const userInfo = await getUserInfo();
+
+    expect(userInfo).toEqual({
+      authType: "OAuth",
+      apiToken: "some-oauth-token",
+      email: "user@example.com",
+      accounts: [
+        { name: "Account One", id: "account-1" },
+        { name: "Account Two", id: "account-2" },
+        { name: "Account Three", id: "account-3" },
+      ],
+    });
+  });
+});
+
+describe("WhoAmI component", () => {
+  it("should return undefined if there is no user", async () => {
+    const { lastFrame } = render(<WhoAmI user={undefined}></WhoAmI>);
+
+    expect(lastFrame()).toMatchInlineSnapshot(
+      `"You are not authenticated. Please run \`wrangler login\`."`
+    );
+  });
+
+  it("should display the user's email and accounts", async () => {
+    const user: UserInfo = {
+      authType: "OAuth",
+      apiToken: "some-oauth-token",
+      email: "user@example.com",
+      accounts: [
+        { name: "Account One", id: "account-1" },
+        { name: "Account Two", id: "account-2" },
+        { name: "Account Three", id: "account-3" },
+      ],
+    };
+
+    const { lastFrame } = render(<WhoAmI user={user}></WhoAmI>);
+
+    expect(lastFrame()).toContain(
+      "You are logged in with an OAuth Token, associated with the email 'user@example.com'!"
+    );
+    expect(lastFrame()).toMatch(/Account Name .+ Account ID/);
+    expect(lastFrame()).toMatch(/Account One .+ account-1/);
+    expect(lastFrame()).toMatch(/Account Two .+ account-2/);
+    expect(lastFrame()).toMatch(/Account Three .+ account-3/);
+  });
+});

package/src/api/form_data.ts

@@ -1,71 +1,11 @@
+import { readFileSync } from "node:fs";
+import { FormData, File } from "undici";
 import type {
   CfWorkerInit,
   CfModuleType,
-  CfVariable,
   CfModule,
+  CfDurableObjectMigrations,
 } 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) {
@@ -84,11 +24,38 @@ export function toMimeType(type: CfModuleType): string {
   }
 }
 
-function toModule(module: CfModule, entryType?: CfModuleType): Blob {
+function toModule(module: CfModule, entryType: CfModuleType): File {
   const { type: moduleType, content } = module;
   const type = toMimeType(moduleType ?? entryType);
+  return new File([content], module.name, { type });
+}
 
-  return new Blob([content], { type });
+export interface WorkerMetadata {
+  /** The name of the entry point module. Only exists when the worker is in the ES module format */
+  main_module?: string;
+  /** The name of the entry point module. Only exists when the worker is in the Service Worker format */
+  body_part?: string;
+  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: "wasm_module"; name: string; part: string }
+    | {
+        type: "durable_object_namespace";
+        name: string;
+        class_name: string;
+        script_name?: string;
+      }
+    | {
+        type: "service";
+        name: string;
+        service: string;
+        environment: string;
+      }
+  )[];
 }
 
 /**
@@ -99,50 +66,76 @@ export function toFormData(worker: CfWorkerInit): FormData {
   const {
     main,
     modules,
-    variables,
+    bindings,
     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);
-  }
+  const metadataBindings: WorkerMetadata["bindings"] = [];
 
-  const metadata =
-    mainType !== "commonjs"
-      ? {
-          main_module: name,
-          bindings,
-        }
-      : {
-          body_part: name,
-          bindings,
-        };
-  if (compatibility_date) {
-    // @ts-expect-error - we should type metadata
-    metadata.compatibility_date = compatibility_date;
-  }
-  if (compatibility_flags) {
-    // @ts-expect-error - we should type metadata
-    metadata.compatibility_flags = compatibility_flags;
-  }
-  if (usage_model) {
-    // @ts-expect-error - we should type metadata
-    metadata.usage_model = usage_model;
-  }
-  if (migrations) {
-    // @ts-expect-error - we should type metadata
-    metadata.migrations = migrations;
+  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 });
+  });
+
+  for (const [name, filePath] of Object.entries(bindings.wasm_modules || {})) {
+    metadataBindings.push({
+      name,
+      type: "wasm_module",
+      part: name,
+    });
+
+    formData.set(
+      name,
+      new File([readFileSync(filePath)], filePath, {
+        type: "application/wasm",
+      })
+    );
   }
 
+  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 (mainType === "commonjs" && modules && modules.length > 0) {
+  if (main.type === "commonjs" && modules && modules.length > 0) {
     throw new TypeError(
       "More than one module can only be specified when type = 'esm'"
     );
@@ -150,8 +143,8 @@ export function toFormData(worker: CfWorkerInit): FormData {
 
   for (const module of [main].concat(modules || [])) {
     const { name } = module;
-    const blob = toModule(module, mainType ?? "esm");
-    formData.set(name, blob, name);
+    const file = toModule(module, main.type ?? "esm");
+    formData.set(name, file);
   }
 
   return formData;

package/src/api/preview.ts

@@ -1,5 +1,6 @@
-import cfetch from "../cfetch";
-import { fetchJson } from "../util/fetch";
+import { URL } from "node:url";
+import { fetch } from "undici";
+import { fetchResult } from "../cfetch";
 import { toFormData } from "./form_data";
 import type { CfAccount, CfWorkerInit } from "./worker";
 
@@ -9,7 +10,7 @@ import type { CfAccount, CfWorkerInit } from "./worker";
  * * If true, then using a `workers.dev` subdomain.
  * * Otherwise, a list of routes under a single zone.
  */
-export type CfPreviewMode = { workers_dev: boolean } | { routes: string[] };
+type CfPreviewMode = { workers_dev: boolean } | { routes: string[] };
 
 /**
  * A preview token.
@@ -60,17 +61,17 @@ async function sessionToken(account: CfAccount): Promise<CfPreviewToken> {
     ? `/zones/${zoneId}/workers/edge-preview`
     : `/accounts/${accountId}/workers/subdomain/edge-preview`;
 
-  const { exchange_url: tokenUrl } = await cfetch<{ exchange_url: string }>(
-    initUrl
-  );
-  const { inspector_websocket: url, token } = await fetchJson()(tokenUrl);
-  const { host } = new URL(url);
+  const { exchange_url } = await fetchResult<{ exchange_url: string }>(initUrl);
+  const { inspector_websocket, token } = (await (
+    await fetch(exchange_url)
+  ).json()) as { inspector_websocket: string; token: string };
+  const { host } = new URL(inspector_websocket);
   const query = `cf_workers_preview_token=${token}`;
 
   return {
     value: token,
     host,
-    inspectorUrl: new URL(`${url}?${query}`),
+    inspectorUrl: new URL(`${inspector_websocket}?${query}`),
     prewarmUrl: new URL(
       `https://${host}/cdn-cgi/workers/preview/prewarm?${query}`
     ),
@@ -96,27 +97,31 @@ export async function previewToken(
   const { value, host, inspectorUrl, prewarmUrl } = await sessionToken(account);
 
   const { accountId, zoneId } = account;
-  const scriptId = zoneId ? randomId() : host.split(".")[0];
+  const scriptId = zoneId ? randomId() : worker.name || host.split(".")[0];
   const url = `/accounts/${accountId}/workers/scripts/${scriptId}/edge-preview`;
 
-  const mode = zoneId ? { routes: ["*/*"] } : { workers_dev: true };
+  const mode: CfPreviewMode = zoneId
+    ? { routes: ["*/*"] }
+    : { workers_dev: true };
+
   const formData = toFormData(worker);
   formData.set("wrangler-session-config", JSON.stringify(mode));
 
-  const { preview_token: token } = await cfetch<{ preview_token: string }>(
-    url,
-    {
-      method: "POST",
-      // @ts-expect-error TODO: fix this
-      body: formData,
-      headers: {
-        "cf-preview-upload-config-token": value,
-      },
-    }
-  );
+  const { preview_token } = await fetchResult<{ preview_token: string }>(url, {
+    method: "POST",
+    body: formData,
+    headers: {
+      "cf-preview-upload-config-token": value,
+    },
+  });
+
   return {
-    value: token,
-    host,
+    value: preview_token,
+    // TODO: verify this works with zoned workers
+    host:
+      worker.name && !zoneId
+        ? `${worker.name}.${host.split(".").slice(1).join(".")}`
+        : host,
     inspectorUrl,
     prewarmUrl,
   };