wrangler 0.0.0-e22f9d7 → 0.0.0-e2a26a0

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,10 +1,10 @@
+import { FormData, File } from "undici";
 import type {
   CfWorkerInit,
   CfModuleType,
   CfModule,
   CfDurableObjectMigrations,
 } from "./worker.js";
-import { FormData, Blob } from "formdata-node";
 
 export function toMimeType(type: CfModuleType): string {
   switch (type) {
@@ -23,14 +23,17 @@ 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 Blob([content], { type });
+  return new File([content], module.name, { type });
 }
 
-interface WorkerMetadata {
+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";
@@ -123,8 +126,8 @@ export function toFormData(worker: CfWorkerInit): FormData {
 
   for (const module of [main].concat(modules || [])) {
     const { name } = module;
-    const blob = toModule(module, main.type ?? "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,4 +1,5 @@
-import fetch from "node-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";
@@ -108,7 +109,6 @@ export async function previewToken(
 
   const { preview_token } = await fetchResult<{ preview_token: string }>(url, {
     method: "POST",
-    // @ts-expect-error TODO: fix this
     body: formData,
     headers: {
       "cf-preview-upload-config-token": value,

package/src/api/worker.ts

@@ -1,6 +1,6 @@
-import type { CfPreviewToken } from "./preview";
+import { fetch } from "undici";
 import { previewToken } from "./preview";
-import fetch from "node-fetch";
+import type { CfPreviewToken } from "./preview";
 
 /**
  * A Cloudflare account.
@@ -53,7 +53,7 @@ export interface CfModule {
    *   }
    * }
    */
-  content: string | BufferSource;
+  content: string | Buffer;
   /**
    * The module type.
    *

package/src/cfetch/index.ts

@@ -1,6 +1,6 @@
-import type { RequestInit } from "node-fetch";
-import { URLSearchParams } from "url";
+import { URLSearchParams } from "node:url";
 import { fetchInternal } from "./internal";
+import type { RequestInit } from "undici";
 
 // Check out https://api.cloudflare.com/ for API docs.
 
@@ -18,16 +18,7 @@ export interface FetchResult<ResponseType = unknown> {
   result_info?: unknown;
 }
 
-/**
- * Make a fetch request for a raw JSON value.
- */
-export async function fetchRaw<ResponseType>(
-  resource: string,
-  init: RequestInit = {},
-  queryParams?: URLSearchParams
-): Promise<ResponseType> {
-  return fetchInternal<ResponseType>(resource, init, queryParams);
-}
+export { fetchKVGetValue } from "./internal";
 
 /**
  * Make a fetch request, and extract the `result` from the JSON response.
@@ -94,9 +85,18 @@ function throwFetchError(
   const errors = response.errors
     .map((error) => `${error.code}: ${error.message}`)
     .join("\n");
-  throw new Error(`Failed to fetch ${resource} - ${errors}`);
+  const error = new Error(`Failed to fetch ${resource} - \n${errors}`);
+  // add the first error code directly to this error
+  // so consumers can use it for specific behaviour
+  const code = response.errors[0]?.code;
+  if (code) {
+    //@ts-expect-error non-standard property on Error
+    error.code = code;
+  }
+  throw error;
 }
 
 function hasCursor(result_info: unknown): result_info is { cursor: string } {
-  return (result_info as { cursor } | undefined)?.cursor !== undefined;
+  const cursor = (result_info as { cursor: string } | undefined)?.cursor;
+  return cursor !== undefined && cursor !== null && cursor !== "";
 }

package/src/cfetch/internal.ts

@@ -1,6 +1,7 @@
-import fetch from "node-fetch";
-import type { RequestInit, HeadersInit } from "node-fetch";
+import { fetch } from "undici";
 import { getAPIToken, loginOrRefreshIfRequired } from "../user";
+import type { URLSearchParams } from "node:url";
+import type { RequestInit, HeadersInit } from "undici";
 
 export const CF_API_BASE_URL =
   process.env.CF_API_BASE_URL || "https://api.cloudflare.com/client/v4";
@@ -30,17 +31,18 @@ export async function fetchInternal<ResponseType>(
     ...init,
     headers,
   });
-
-  if (response.ok) {
-    return (await response.json()) as ResponseType;
-  } else {
+  const jsonText = await response.text();
+  try {
+    const json = JSON.parse(jsonText);
+    return json as ResponseType;
+  } catch (e) {
     throw new Error(
-      `Failed to fetch ${resource} - ${response.status}: ${response.statusText}`
+      `Failed to fetch ${resource} - ${response.status}: ${response.statusText}\nInvalid JSON response:\n${jsonText}`
     );
   }
 }
 
-function cloneHeaders(headers: HeadersInit): HeadersInit {
+function cloneHeaders(headers: HeadersInit | undefined): HeadersInit {
   return { ...headers };
 }
 
@@ -67,3 +69,33 @@ function addAuthorizationHeader(headers: HeadersInit, apiToken: string): void {
   }
   headers["Authorization"] = `Bearer ${apiToken}`;
 }
+
+/**
+ * The implementation for fetching a kv value from the cloudflare API.
+ * We special-case this one call, because it's the only API call that
+ * doesn't return json. We inline the implementation and try not to share
+ * any code with the other calls. We should push back on any new APIs that
+ * try to introduce non-"standard" response structures.
+ */
+
+export async function fetchKVGetValue(
+  accountId: string,
+  namespaceId: string,
+  key: string
+): Promise<string> {
+  await requireLoggedIn();
+  const apiToken = requireApiToken();
+  const headers = { Authorization: `Bearer ${apiToken}` };
+  const resource = `${CF_API_BASE_URL}/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${key}`;
+  const response = await fetch(resource, {
+    method: "GET",
+    headers,
+  });
+  if (response.ok) {
+    return await response.text();
+  } else {
+    throw new Error(
+      `Failed to fetch ${resource} - ${response.status}: ${response.statusText});`
+    );
+  }
+}