wrangler 0.0.0-e95e5a0 → 0.0.0-e981d0be5

package/src/__tests__/user.test.ts

@@ -1,131 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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/bundle.ts

@@ -1,169 +0,0 @@
-import assert from "node:assert";
-import * as fs from "node:fs";
-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;
-};
-
-/**
- * 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: "esm",
-    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()]
-        : []),
-    ],
-    ...(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

@@ -1,104 +0,0 @@
-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;
-}
-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
-): Promise<ResponseType> {
-  const json = await fetchInternal<FetchResult<ResponseType>>(
-    resource,
-    init,
-    queryParams
-  );
-  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: "Received a bad response from the API",
-    notes: response.errors.map((err) => ({
-      text: err.code ? `${err.message} [code: ${err.code}]` : err.message,
-    })),
-  });
-  // 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 !== "";
-}

package/src/cfetch/internal.ts

@@ -1,137 +0,0 @@
-import { fetch, Headers } from "undici";
-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
-): Promise<ResponseType> {
-  await requireLoggedIn();
-  const apiToken = requireApiToken();
-  const headers = cloneHeaders(init.headers);
-  addAuthorizationHeader(headers, apiToken);
-
-  const queryString = queryParams ? `?${queryParams.toString()}` : "";
-  const method = init.method ?? "GET";
-  const response = await fetch(
-    `${getCloudflareAPIBaseURL()}${resource}${queryString}`,
-    {
-      method,
-      ...init,
-      headers,
-    }
-  );
-  const jsonText = await response.text();
-  try {
-    return parseJSON(jsonText) as ResponseType;
-  } 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 addAuthorizationHeader(
-  headers: Record<string, string>,
-  apiToken: string
-): void {
-  if ("Authorization" in headers) {
-    throw new Error(
-      "The request already specifies an authorisation header - cannot add a new one."
-    );
-  }
-  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 = `${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});`
-    );
-  }
-}

package/src/cli.ts

@@ -1,13 +0,0 @@
-import "dotenv/config"; // Grab locally specified env params from a `.env` file.
-import process from "process";
-import { hideBin } from "yargs/helpers";
-import { FatalError } from "./errors";
-import { main } from ".";
-
-main(hideBin(process.argv)).catch((e) => {
-  // The logging of any error that was thrown from `main()` is handled in the `yargs.fail()` handler.
-  // Here we just want to ensure that the process exits with a non-zero code.
-  // We don't want to do this inside the `main()` function, since that would kill the process when running our tests.
-  const exitCode = (e instanceof FatalError && e.code) || 1;
-  process.exit(exitCode);
-});