wrangler 0.0.0-e928f94 → 0.0.0-e978986

package/src/__tests__/user.test.ts

@@ -0,0 +1,131 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import fetchMock from "jest-fetch-mock";
+import {
+  readAuthConfigFile,
+  requireAuth,
+  USER_AUTH_CONFIG_FILE,
+  writeAuthConfigFile,
+} from "../user";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { useMockIsTTY } from "./helpers/mock-istty";
+import { mockOAuthFlow } from "./helpers/mock-oauth-flow";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+import type { Config } from "../config";
+import type { UserAuthConfig } from "../user";
+
+describe("User", () => {
+  runInTempDir({ homedir: "./home" });
+  const std = mockConsoleMethods();
+  const {
+    mockOAuthServerCallback,
+    mockGrantAccessToken,
+    mockGrantAuthorization,
+    mockRevokeAuthorization,
+    mockExchangeRefreshTokenForAccessToken,
+  } = mockOAuthFlow();
+
+  const { setIsTTY } = useMockIsTTY();
+
+  describe("login", () => {
+    it("should login a user when `wrangler login` is run", async () => {
+      mockOAuthServerCallback();
+      const accessTokenRequest = mockGrantAccessToken({ respondWith: "ok" });
+      mockGrantAuthorization({ respondWith: "success" });
+
+      await runWrangler("login");
+
+      expect(accessTokenRequest.actual.url).toEqual(
+        accessTokenRequest.expected.url
+      );
+      expect(accessTokenRequest.actual.method).toEqual(
+        accessTokenRequest.expected.method
+      );
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Attempting to login via OAuth...
+        Successfully logged in."
+      `);
+
+      expect(readAuthConfigFile()).toEqual<UserAuthConfig>({
+        api_token: undefined,
+        oauth_token: "test-access-token",
+        refresh_token: "test-refresh-token",
+        expiration_time: expect.any(String),
+      });
+    });
+  });
+
+  describe("logout", () => {
+    it("should exit with a message stating the user is not logged in", async () => {
+      await runWrangler("logout");
+      expect(std.out).toMatchInlineSnapshot(`"Not logged in, exiting..."`);
+    });
+
+    it("should logout user that has been properly logged in", async () => {
+      writeAuthConfigFile({
+        oauth_token: "some-oauth-tok",
+        refresh_token: "some-refresh-tok",
+      });
+      const outcome = mockRevokeAuthorization();
+
+      await runWrangler("logout");
+
+      expect(outcome.actual.url).toEqual(
+        "https://dash.cloudflare.com/oauth2/revoke"
+      );
+      expect(outcome.actual.method).toEqual("POST");
+
+      expect(std.out).toMatchInlineSnapshot(`"Successfully logged out."`);
+
+      // Make sure that we made the request to logout.
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+
+      // Make sure that logout removed the config file containing the auth tokens.
+      const config = path.join(os.homedir(), USER_AUTH_CONFIG_FILE);
+      expect(fs.existsSync(config)).toBeFalsy();
+    });
+  });
+
+  // TODO: Improve OAuth mocking to handle `/token` endpoints from different calls
+  it("should handle errors for failed token refresh", async () => {
+    setIsTTY(false);
+    mockOAuthServerCallback();
+    writeAuthConfigFile({
+      oauth_token: "hunter2",
+      refresh_token: "Order 66",
+    });
+    mockGrantAuthorization({ respondWith: "success" });
+
+    mockExchangeRefreshTokenForAccessToken({
+      respondWith: "badResponse",
+    });
+
+    // Handles the requireAuth error throw from failed login that is unhandled due to directly calling it here
+    await expect(
+      requireAuth({} as Config)
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `"Did not login, quitting..."`
+    );
+  });
+
+  it("should confirm no error message when refresh is successful", async () => {
+    setIsTTY(false);
+    mockOAuthServerCallback();
+    writeAuthConfigFile({
+      oauth_token: "hunter2",
+      refresh_token: "Order 66",
+    });
+    mockGrantAuthorization({ respondWith: "success" });
+
+    mockExchangeRefreshTokenForAccessToken({
+      respondWith: "refreshSuccess",
+    });
+
+    // Handles the requireAuth error throw from failed login that is unhandled due to directly calling it here
+    await expect(requireAuth({} as Config)).rejects.toThrowError();
+    expect(std.err).toContain("");
+  });
+});

package/src/__tests__/whoami.test.tsx

@@ -0,0 +1,105 @@
+import { render } from "ink-testing-library";
+import React from "react";
+import { writeAuthConfigFile } from "../user";
+import { getUserInfo, WhoAmI } from "../whoami";
+import { setMockResponse } from "./helpers/mock-cfetch";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { useMockIsTTY } from "./helpers/mock-istty";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import type { UserInfo } from "../whoami";
+
+describe("getUserInfo()", () => {
+  runInTempDir({ homedir: "./home" });
+  const std = mockConsoleMethods();
+  const { setIsTTY } = useMockIsTTY();
+
+  beforeEach(() => {
+    setIsTTY(true);
+  });
+
+  it("should return undefined if there is no config file", async () => {
+    const userInfo = await getUserInfo();
+    expect(userInfo).toBeUndefined();
+  });
+
+  it("should return undefined if there is an empty config file", async () => {
+    writeAuthConfigFile({});
+    const userInfo = await getUserInfo();
+    expect(userInfo).toBeUndefined();
+  });
+
+  it("should return the user's email and accounts if authenticated via config token", async () => {
+    writeAuthConfigFile({ oauth_token: "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" },
+      ];
+    });
+
+    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" },
+      ],
+    });
+  });
+
+  it("should display a warning message if the config file contains a legacy api_token field", async () => {
+    writeAuthConfigFile({ api_token: "API_TOKEN" });
+    await getUserInfo();
+    expect(std.warn).toMatchInlineSnapshot(`
+      "▲ [WARNING] It looks like you have used Wrangler 1's \`config\` command to login with an API token.
+
+        This is no longer supported in the current version of Wrangler.
+        If you wish to authenticate via an API token then please set the \`CLOUDFLARE_API_TOKEN\`
+        environment variable.
+
+      "
+    `);
+  });
+});
+
+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/abort.d.ts

@@ -0,0 +1,3 @@
+declare interface AbortSignal {
+  addEventListener(event: "abort", handler: () => void);
+}

package/src/bundle.ts

@@ -0,0 +1,200 @@
+import assert from "node:assert";
+import * as fs from "node:fs";
+import { builtinModules } from "node:module";
+import * as path from "node:path";
+import NodeGlobalsPolyfills from "@esbuild-plugins/node-globals-polyfill";
+import NodeModulesPolyfills from "@esbuild-plugins/node-modules-polyfill";
+import * as esbuild from "esbuild";
+import createModuleCollector from "./module-collection";
+import type { Config } from "./config";
+import type { Entry } from "./entry";
+import type { CfModule } from "./worker";
+
+type BundleResult = {
+  modules: CfModule[];
+  resolvedEntryPointPath: string;
+  bundleType: "esm" | "commonjs";
+  stop: (() => void) | undefined;
+};
+
+/**
+ * Searches for any uses of node's builtin modules, and throws an error if it
+ * finds anything. This plugin is only used when nodeCompat is not enabled.
+ * Supports both regular node builtins, and the new "node:<MODULE>" format.
+ */
+const checkForNodeBuiltinsPlugin = {
+  name: "checkForNodeBuiltins",
+  setup(build: esbuild.PluginBuild) {
+    build.onResolve(
+      {
+        filter: new RegExp(
+          "^(" +
+            builtinModules.join("|") +
+            "|" +
+            builtinModules.map((module) => "node:" + module).join("|") +
+            ")$"
+        ),
+      },
+      () => {
+        throw new Error(
+          `Detected a Node builtin module import while Node compatibility is disabled.\nAdd node_compat = true to your wrangler.toml file to enable Node compatibility.`
+        );
+      }
+    );
+  },
+};
+
+/**
+ * Generate a bundle for the worker identified by the arguments passed in.
+ */
+export async function bundleWorker(
+  entry: Entry,
+  destination: string,
+  options: {
+    serveAssetsFromWorker: boolean;
+    jsxFactory: string | undefined;
+    jsxFragment: string | undefined;
+    rules: Config["rules"];
+    watch?: esbuild.WatchMode;
+    tsconfig: string | undefined;
+    minify: boolean | undefined;
+    nodeCompat: boolean | undefined;
+  }
+): Promise<BundleResult> {
+  const {
+    serveAssetsFromWorker,
+    jsxFactory,
+    jsxFragment,
+    rules,
+    watch,
+    tsconfig,
+    minify,
+    nodeCompat,
+  } = options;
+  const entryDirectory = path.dirname(entry.file);
+  const moduleCollector = createModuleCollector({
+    wrangler1xlegacyModuleReferences: {
+      rootDirectory: entryDirectory,
+      fileNames: new Set(
+        fs
+          .readdirSync(entryDirectory, { withFileTypes: true })
+          .filter(
+            (dirEntry) =>
+              dirEntry.isFile() && dirEntry.name !== path.basename(entry.file)
+          )
+          .map((dirEnt) => dirEnt.name)
+      ),
+    },
+    format: entry.format,
+    rules,
+  });
+
+  const result = await esbuild.build({
+    ...getEntryPoint(entry.file, serveAssetsFromWorker),
+    bundle: true,
+    absWorkingDir: entry.directory,
+    outdir: destination,
+    external: ["__STATIC_CONTENT_MANIFEST"],
+    format: entry.format === "modules" ? "esm" : "iife",
+    target: "es2020",
+    sourcemap: true,
+    minify,
+    metafile: true,
+    conditions: ["worker", "browser"],
+    ...(process.env.NODE_ENV && {
+      define: {
+        "process.env.NODE_ENV": `"${process.env.NODE_ENV}"`,
+        ...(nodeCompat ? { global: "globalThis" } : {}),
+      },
+    }),
+    loader: {
+      ".js": "jsx",
+      ".mjs": "jsx",
+      ".cjs": "jsx",
+    },
+    plugins: [
+      moduleCollector.plugin,
+      ...(nodeCompat
+        ? [NodeGlobalsPolyfills({ buffer: true }), NodeModulesPolyfills()]
+        : // we use checkForNodeBuiltinsPlugin to throw a nicer error
+          // if we find node builtins when nodeCompat isn't turned on
+          [checkForNodeBuiltinsPlugin]),
+    ],
+    ...(jsxFactory && { jsxFactory }),
+    ...(jsxFragment && { jsxFragment }),
+    ...(tsconfig && { tsconfig }),
+    watch,
+  });
+
+  const entryPointOutputs = Object.entries(result.metafile.outputs).filter(
+    ([_path, output]) => output.entryPoint !== undefined
+  );
+  assert(
+    entryPointOutputs.length > 0,
+    `Cannot find entry-point "${entry.file}" in generated bundle.` +
+      listEntryPoints(entryPointOutputs)
+  );
+  assert(
+    entryPointOutputs.length < 2,
+    "More than one entry-point found for generated bundle." +
+      listEntryPoints(entryPointOutputs)
+  );
+
+  const entryPointExports = entryPointOutputs[0][1].exports;
+  const bundleType = entryPointExports.length > 0 ? "esm" : "commonjs";
+
+  return {
+    modules: moduleCollector.modules,
+    resolvedEntryPointPath: path.resolve(
+      entry.directory,
+      entryPointOutputs[0][0]
+    ),
+    bundleType,
+    stop: result.stop,
+  };
+}
+
+type EntryPoint =
+  | { stdin: esbuild.StdinOptions; nodePaths: string[] }
+  | { entryPoints: string[] };
+
+/**
+ * Create an object that describes the entry point for esbuild.
+ *
+ * If we are using the experimental asset handling, then the entry point is
+ * actually a shim worker that will either return an asset from a KV store,
+ * or delegate to the actual worker.
+ */
+function getEntryPoint(
+  entryFile: string,
+  serveAssetsFromWorker: boolean
+): EntryPoint {
+  if (serveAssetsFromWorker) {
+    return {
+      stdin: {
+        contents: fs
+          .readFileSync(
+            path.join(__dirname, "../templates/static-asset-facade.js"),
+            "utf8"
+          )
+          .replace("__ENTRY_POINT__", entryFile),
+        sourcefile: "static-asset-facade.js",
+        resolveDir: path.dirname(entryFile),
+      },
+      nodePaths: [path.join(__dirname, "../vendor")],
+    };
+  } else {
+    return { entryPoints: [entryFile] };
+  }
+}
+
+/**
+ * Generate a string that describes the entry-points that were identified by esbuild.
+ */
+function listEntryPoints(
+  outputs: [string, ValueOf<esbuild.Metafile["outputs"]>][]
+): string {
+  return outputs.map(([_input, output]) => output.entryPoint).join("\n");
+}
+
+type ValueOf<T> = T[keyof T];

package/src/cfetch/index.ts

@@ -0,0 +1,121 @@
+import { URLSearchParams } from "node:url";
+import { ParseError } from "../parse";
+import { fetchInternal } from "./internal";
+import type { RequestInit } from "undici";
+
+// Check out https://api.cloudflare.com/ for API docs.
+
+export { getCloudflareAPIBaseURL as getCloudflareApiBaseUrl } from "./internal";
+
+export interface FetchError {
+  code: number;
+  message: string;
+  error_chain?: FetchError[];
+}
+export interface FetchResult<ResponseType = unknown> {
+  success: boolean;
+  result: ResponseType;
+  errors: FetchError[];
+  messages: string[];
+  result_info?: unknown;
+}
+
+export { fetchKVGetValue } from "./internal";
+
+/**
+ * Make a fetch request, and extract the `result` from the JSON response.
+ */
+export async function fetchResult<ResponseType>(
+  resource: string,
+  init: RequestInit = {},
+  queryParams?: URLSearchParams,
+  abortSignal?: AbortSignal
+): Promise<ResponseType> {
+  const json = await fetchInternal<FetchResult<ResponseType>>(
+    resource,
+    init,
+    queryParams,
+    abortSignal
+  );
+  if (json.success) {
+    return json.result;
+  } else {
+    throwFetchError(resource, json);
+  }
+}
+
+/**
+ * Make a fetch request for a list of values,
+ * extracting the `result` from the JSON response,
+ * and repeating the request if the results are paginated.
+ */
+export async function fetchListResult<ResponseType>(
+  resource: string,
+  init: RequestInit = {},
+  queryParams?: URLSearchParams
+): Promise<ResponseType[]> {
+  const results: ResponseType[] = [];
+  let getMoreResults = true;
+  let cursor: string | undefined;
+  while (getMoreResults) {
+    if (cursor) {
+      queryParams = new URLSearchParams(queryParams);
+      queryParams.set("cursor", cursor);
+    }
+    const json = await fetchInternal<FetchResult<ResponseType[]>>(
+      resource,
+      init,
+      queryParams
+    );
+    if (json.success) {
+      results.push(...json.result);
+      if (hasCursor(json.result_info)) {
+        cursor = json.result_info?.cursor;
+      } else {
+        getMoreResults = false;
+      }
+    } else {
+      throwFetchError(resource, json);
+    }
+  }
+  return results;
+}
+
+function throwFetchError(
+  resource: string,
+  response: FetchResult<unknown>
+): never {
+  const error = new ParseError({
+    text: `A request to the Cloudflare API (${resource}) failed.`,
+    notes: response.errors.map((err) => ({
+      text: renderError(err),
+    })),
+  });
+  // 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 } {
+  const cursor = (result_info as { cursor: string } | undefined)?.cursor;
+  return cursor !== undefined && cursor !== null && cursor !== "";
+}
+
+function renderError(err: FetchError, level = 0): string {
+  const chainedMessages =
+    err.error_chain
+      ?.map(
+        (chainedError) =>
+          `\n${"  ".repeat(level)}- ${renderError(chainedError, level + 1)}`
+      )
+      .join("\n") ?? "";
+  return (
+    (err.code ? `${err.message} [code: ${err.code}]` : err.message) +
+    chainedMessages
+  );
+}

package/src/cfetch/internal.ts

@@ -0,0 +1,145 @@
+import { fetch, Headers } from "undici";
+import { version as wranglerVersion } from "../../package.json";
+import { getEnvironmentVariableFactory } from "../environment-variables";
+import { ParseError, parseJSON } from "../parse";
+import { getAPIToken, loginOrRefreshIfRequired } from "../user";
+import type { URLSearchParams } from "node:url";
+import type { RequestInit, HeadersInit } from "undici";
+
+/**
+ * Get the URL to use to access the Cloudflare API.
+ */
+export const getCloudflareAPIBaseURL = getEnvironmentVariableFactory({
+  variableName: "CLOUDFLARE_API_BASE_URL",
+  deprecatedName: "CF_API_BASE_URL",
+  defaultValue: "https://api.cloudflare.com/client/v4",
+});
+
+/**
+ * Make a fetch request to the Cloudflare API.
+ *
+ * This function handles acquiring the API token and logging the caller in, as necessary.
+ *
+ * Check out https://api.cloudflare.com/ for API docs.
+ *
+ * This function should not be used directly, instead use the functions in `cfetch/index.ts`.
+ */
+export async function fetchInternal<ResponseType>(
+  resource: string,
+  init: RequestInit = {},
+  queryParams?: URLSearchParams,
+  abortSignal?: AbortSignal
+): Promise<ResponseType> {
+  await requireLoggedIn();
+  const apiToken = requireApiToken();
+  const headers = cloneHeaders(init.headers);
+  addAuthorizationHeaderIfUnspecified(headers, apiToken);
+  addUserAgent(headers);
+
+  const queryString = queryParams ? `?${queryParams.toString()}` : "";
+  const method = init.method ?? "GET";
+  const response = await fetch(
+    `${getCloudflareAPIBaseURL()}${resource}${queryString}`,
+    {
+      method,
+      ...init,
+      headers,
+      signal: abortSignal,
+    }
+  );
+  const jsonText = await response.text();
+  try {
+    return parseJSON<ResponseType>(jsonText);
+  } catch (err) {
+    throw new ParseError({
+      text: "Received a malformed response from the API",
+      notes: [
+        {
+          text: truncate(jsonText, 100),
+        },
+        {
+          text: `${method} ${resource} -> ${response.status} ${response.statusText}`,
+        },
+      ],
+    });
+  }
+}
+
+function truncate(text: string, maxLength: number): string {
+  const { length } = text;
+  if (length <= maxLength) {
+    return text;
+  }
+  return `${text.substring(0, maxLength)}... (length = ${length})`;
+}
+
+function cloneHeaders(
+  headers: HeadersInit | undefined
+): Record<string, string> {
+  return headers instanceof Headers
+    ? Object.fromEntries(headers.entries())
+    : Array.isArray(headers)
+    ? Object.fromEntries(headers)
+    : { ...headers };
+}
+
+async function requireLoggedIn(): Promise<void> {
+  const loggedIn = await loginOrRefreshIfRequired();
+  if (!loggedIn) {
+    throw new Error("Not logged in.");
+  }
+}
+
+function requireApiToken(): string {
+  const authToken = getAPIToken();
+  if (!authToken) {
+    throw new Error("No API token found.");
+  }
+  return authToken;
+}
+
+function addAuthorizationHeaderIfUnspecified(
+  headers: Record<string, string>,
+  apiToken: string
+): void {
+  if (!("Authorization" in headers)) {
+    headers["Authorization"] = `Bearer ${apiToken}`;
+  }
+}
+
+function addUserAgent(headers: Record<string, string>): void {
+  headers["User-Agent"] = `wrangler/${wranglerVersion}`;
+}
+
+/**
+ * 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.
+ *
+ * Note: any calls to fetchKVGetValue must call encodeURIComponent on key
+ * before passing it
+ */
+
+export async function fetchKVGetValue(
+  accountId: string,
+  namespaceId: string,
+  key: string
+): Promise<string> {
+  await requireLoggedIn();
+  const apiToken = requireApiToken();
+  const headers = { Authorization: `Bearer ${apiToken}` };
+  const resource = `${getCloudflareAPIBaseURL()}/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});`
+    );
+  }
+}