wrangler 0.0.0-e1c615f → 0.0.0-e5d3690

package/src/__tests__/whoami.test.tsx

@@ -0,0 +1,130 @@
+import React from "react";
+import os from "node:os";
+import path from "node:path";
+import { render } from "ink-testing-library";
+import type { UserInfo } from "../whoami";
+import { getUserInfo, WhoAmI } from "../whoami";
+import { runInTempDir } from "./run-in-tmp";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { setMockResponse } from "./mock-cfetch";
+import { initialise } from "../user";
+
+const ORIGINAL_CF_API_TOKEN = process.env.CF_API_TOKEN;
+const ORIGINAL_CF_ACCOUNT_ID = process.env.CF_ACCOUNT_ID;
+
+describe("getUserInfo()", () => {
+  runInTempDir();
+
+  beforeEach(() => {
+    // Clear the environment variables, so we can control them in the tests
+    delete process.env.CF_API_TOKEN;
+    delete process.env.CF_ACCOUNT_ID;
+    // Override where the home directory is so that we can specify a user config
+    mkdirSync("./home");
+    jest.spyOn(os, "homedir").mockReturnValue("./home");
+  });
+
+  afterEach(() => {
+    // Reset any changes to the environment variables
+    process.env.CF_API_TOKEN = ORIGINAL_CF_API_TOKEN;
+    process.env.CF_ACCOUNT_ID = ORIGINAL_CF_ACCOUNT_ID;
+  });
+
+  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/);
+  });
+});
+
+function writeUserConfig(
+  oauth_token?: string,
+  refresh_token?: string,
+  expiration_time?: string
+) {
+  const lines: string[] = [];
+  if (oauth_token) {
+    lines.push(`oauth_token = "${oauth_token}"`);
+  }
+  if (refresh_token) {
+    lines.push(`refresh_token = "${refresh_token}"`);
+  }
+  if (expiration_time) {
+    lines.push(`expiration_time = "${expiration_time}"`);
+  }
+  const configPath = path.join(os.homedir(), ".wrangler/config");
+  mkdirSync(configPath, { recursive: true });
+  writeFileSync(
+    path.join(configPath, "default.toml"),
+    lines.join("\n"),
+    "utf-8"
+  );
+}

package/src/api/form_data.ts

@@ -23,7 +23,7 @@ export function toMimeType(type: CfModuleType): string {
   }
 }
 
-function toModule(module: CfModule, entryType?: CfModuleType): Blob {
+function toModule(module: CfModule, entryType: CfModuleType): Blob {
   const { type: moduleType, content } = module;
   const type = toMimeType(moduleType ?? entryType);
 

package/src/api/worker.ts

@@ -112,7 +112,7 @@ export interface CfWorkerInit {
   /**
    * The name of the worker.
    */
-  name: string | void;
+  name: string | undefined;
   /**
    * The entrypoint module.
    */
@@ -120,7 +120,7 @@ export interface CfWorkerInit {
   /**
    * The list of additional modules.
    */
-  modules: void | CfModule[];
+  modules: undefined | CfModule[];
   /**
    * All the bindings
    */
@@ -130,10 +130,10 @@ export interface CfWorkerInit {
     vars?: CfVars;
     services?: CfService[];
   };
-  migrations: void | CfDurableObjectMigrations;
-  compatibility_date: string | void;
-  compatibility_flags: void | string[];
-  usage_model: void | "bundled" | "unbound";
+  migrations: undefined | CfDurableObjectMigrations;
+  compatibility_date: string | undefined;
+  compatibility_flags: undefined | string[];
+  usage_model: undefined | "bundled" | "unbound";
 }
 
 /**

package/src/cfetch/index.ts

@@ -94,9 +94,17 @@ 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;
+  return (result_info as { cursor: string } | undefined)?.cursor !== undefined;
 }

package/src/cfetch/internal.ts

@@ -31,15 +31,21 @@ export async function fetchInternal<ResponseType>(
     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 | undefined): HeadersInit {
+  return { ...headers };
+}
+
 async function requireLoggedIn(): Promise<void> {
   const loggedIn = await loginOrRefreshIfRequired();
   if (!loggedIn) {
@@ -55,10 +61,6 @@ function requireApiToken(): string {
   return apiToken;
 }
 
-function cloneHeaders(headers: HeadersInit): HeadersInit {
-  return { ...headers };
-}
-
 function addAuthorizationHeader(headers: HeadersInit, apiToken: string): void {
   if (headers["Authorization"]) {
     throw new Error(