wrangler 0.0.0-e5d3690 → 0.0.0-e5dbedd78

package/src/__tests__/run-wrangler.ts

@@ -1,32 +0,0 @@
-import { main } from "../index";
-
-/**
- * Run the wrangler CLI tool in tests, capturing the logging output.
- */
-export async function runWrangler(cmd?: string) {
-  const logSpy = jest.spyOn(console, "log").mockImplementation();
-  const errorSpy = jest.spyOn(console, "error").mockImplementation();
-  const warnSpy = jest.spyOn(console, "warn").mockImplementation();
-  try {
-    let error: unknown = undefined;
-    try {
-      await main(cmd?.split(" ") ?? []);
-    } catch (e) {
-      error = e;
-    }
-    return {
-      error,
-      stdout: captureCalls(logSpy),
-      stderr: captureCalls(errorSpy),
-      warnings: captureCalls(warnSpy),
-    };
-  } finally {
-    logSpy.mockRestore();
-    errorSpy.mockRestore();
-    warnSpy.mockRestore();
-  }
-}
-
-function captureCalls(spy: jest.SpyInstance): string {
-  return spy.mock.calls.flat(2).join("\n");
-}

package/src/__tests__/whoami.test.tsx

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

@@ -1,131 +0,0 @@
-import type {
-  CfWorkerInit,
-  CfModuleType,
-  CfModule,
-  CfDurableObjectMigrations,
-} from "./worker.js";
-import { FormData, Blob } from "formdata-node";
-
-export function toMimeType(type: CfModuleType): string {
-  switch (type) {
-    case "esm":
-      return "application/javascript+module";
-    case "commonjs":
-      return "application/javascript";
-    case "compiled-wasm":
-      return "application/wasm";
-    case "buffer":
-      return "application/octet-stream";
-    case "text":
-      return "text/plain";
-    default:
-      throw new TypeError("Unsupported module: " + type);
-  }
-}
-
-function toModule(module: CfModule, entryType: CfModuleType): Blob {
-  const { type: moduleType, content } = module;
-  const type = toMimeType(moduleType ?? entryType);
-
-  return new Blob([content], { type });
-}
-
-interface WorkerMetadata {
-  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: "durable_object_namespace";
-        name: string;
-        class_name: string;
-        script_name?: string;
-      }
-    | {
-        type: "service";
-        name: string;
-        service: string;
-        environment: string;
-      }
-  )[];
-}
-
-/**
- * Creates a `FormData` upload from a `CfWorkerInit`.
- */
-export function toFormData(worker: CfWorkerInit): FormData {
-  const formData = new FormData();
-  const {
-    main,
-    modules,
-    bindings,
-    migrations,
-    usage_model,
-    compatibility_date,
-    compatibility_flags,
-  } = worker;
-
-  const metadataBindings: WorkerMetadata["bindings"] = [];
-
-  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 });
-  });
-
-  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 (main.type === "commonjs" && modules && modules.length > 0) {
-    throw new TypeError(
-      "More than one module can only be specified when type = 'esm'"
-    );
-  }
-
-  for (const module of [main].concat(modules || [])) {
-    const { name } = module;
-    const blob = toModule(module, main.type ?? "esm");
-    formData.set(name, blob, name);
-  }
-
-  return formData;
-}

package/src/api/preview.ts

@@ -1,128 +0,0 @@
-import fetch from "node-fetch";
-import { fetchResult } from "../cfetch";
-import { toFormData } from "./form_data";
-import type { CfAccount, CfWorkerInit } from "./worker";
-
-/**
- * A preview mode.
- *
- * * If true, then using a `workers.dev` subdomain.
- * * Otherwise, a list of routes under a single zone.
- */
-type CfPreviewMode = { workers_dev: boolean } | { routes: string[] };
-
-/**
- * A preview token.
- */
-export interface CfPreviewToken {
-  /**
-   * The header value required to trigger a preview.
-   *
-   * @example
-   * const headers = { 'cf-workers-preview-token': value }
-   * const response = await fetch('https://' + host, { headers })
-   */
-  value: string;
-  /**
-   * The host where the preview is available.
-   */
-  host: string;
-  /**
-   * A websocket url to a DevTools inspector.
-   *
-   * Workers does not have a fully-featured implementation
-   * of the Chrome DevTools protocol, but supports the following:
-   *  * `console.log()` output.
-   *  * `Error` stack traces.
-   *  * `fetch()` events.
-   *
-   * There is no support for breakpoints, but we want to implement
-   * this eventually.
-   *
-   * @link https://chromedevtools.github.io/devtools-protocol/
-   */
-  inspectorUrl: URL;
-  /**
-   * A url to prewarm the preview session.
-   *
-   * @example
-   * fetch(prewarmUrl, { method: 'POST' })
-   */
-  prewarmUrl: URL;
-}
-
-/**
- * Generates a preview session token.
- */
-async function sessionToken(account: CfAccount): Promise<CfPreviewToken> {
-  const { accountId, zoneId } = account;
-  const initUrl = zoneId
-    ? `/zones/${zoneId}/workers/edge-preview`
-    : `/accounts/${accountId}/workers/subdomain/edge-preview`;
-
-  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(`${inspector_websocket}?${query}`),
-    prewarmUrl: new URL(
-      `https://${host}/cdn-cgi/workers/preview/prewarm?${query}`
-    ),
-  };
-}
-
-// Credit: https://stackoverflow.com/a/2117523
-function randomId(): string {
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
-    const r = (Math.random() * 16) | 0,
-      v = c == "x" ? r : (r & 0x3) | 0x8;
-    return v.toString(16);
-  });
-}
-
-/**
- * Creates a preview token.
- */
-export async function previewToken(
-  account: CfAccount,
-  worker: CfWorkerInit
-): Promise<CfPreviewToken> {
-  const { value, host, inspectorUrl, prewarmUrl } = await sessionToken(account);
-
-  const { accountId, zoneId } = account;
-  const scriptId = zoneId ? randomId() : worker.name || host.split(".")[0];
-  const url = `/accounts/${accountId}/workers/scripts/${scriptId}/edge-preview`;
-
-  const mode: CfPreviewMode = zoneId
-    ? { routes: ["*/*"] }
-    : { workers_dev: true };
-
-  const formData = toFormData(worker);
-  formData.set("wrangler-session-config", JSON.stringify(mode));
-
-  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,
-    },
-  });
-
-  return {
-    value: preview_token,
-    // TODO: verify this works with zoned workers
-    host:
-      worker.name && !zoneId
-        ? `${worker.name}.${host.split(".").slice(1).join(".")}`
-        : host,
-    inspectorUrl,
-    prewarmUrl,
-  };
-}

package/src/api/worker.ts

@@ -1,155 +0,0 @@
-import type { CfPreviewToken } from "./preview";
-import { previewToken } from "./preview";
-import fetch from "node-fetch";
-
-/**
- * A Cloudflare account.
- */
-export interface CfAccount {
-  /**
-   * An API token.
-   *
-   * @link https://api.cloudflare.com/#user-api-tokens-properties
-   */
-  apiToken: string;
-  /**
-   * An account ID.
-   */
-  accountId: string;
-  /**
-   * A zone ID, only required if not using `workers.dev`.
-   */
-  zoneId?: string;
-}
-
-/**
- * A module type.
- */
-export type CfModuleType =
-  | "esm"
-  | "commonjs"
-  | "compiled-wasm"
-  | "text"
-  | "buffer";
-
-/**
- * An imported module.
- */
-export interface CfModule {
-  /**
-   * The module name.
-   *
-   * @example
-   * './src/index.js'
-   */
-  name: string;
-  /**
-   * The module content, usually JavaScript or WASM code.
-   *
-   * @example
-   * export default {
-   *   async fetch(request) {
-   *     return new Response('Ok')
-   *   }
-   * }
-   */
-  content: string | BufferSource;
-  /**
-   * The module type.
-   *
-   * If absent, will default to the main module's type.
-   */
-  type?: CfModuleType;
-}
-
-/**
- * A map of variable names to values.
- */
-interface CfVars {
-  [key: string]: string;
-}
-
-/**
- * A KV namespace.
- */
-interface CfKvNamespace {
-  binding: string;
-  id: string;
-}
-
-/**
- * A Durable Object.
- */
-interface CfDurableObject {
-  name: string;
-  class_name: string;
-  script_name?: string;
-}
-
-/**
- * A Service.
- */
-interface CfService {
-  name: string;
-  service: string;
-  environment: string;
-}
-
-export interface CfDurableObjectMigrations {
-  old_tag?: string;
-  new_tag: string;
-  steps: {
-    new_classes?: string[];
-    renamed_classes?: string[];
-    deleted_classes?: string[];
-  }[];
-}
-
-/**
- * Options for creating a `CfWorker`.
- */
-export interface CfWorkerInit {
-  /**
-   * The name of the worker.
-   */
-  name: string | undefined;
-  /**
-   * The entrypoint module.
-   */
-  main: CfModule;
-  /**
-   * The list of additional modules.
-   */
-  modules: undefined | CfModule[];
-  /**
-   * All the bindings
-   */
-  bindings: {
-    kv_namespaces?: CfKvNamespace[];
-    durable_objects?: { bindings: CfDurableObject[] };
-    vars?: CfVars;
-    services?: CfService[];
-  };
-  migrations: undefined | CfDurableObjectMigrations;
-  compatibility_date: string | undefined;
-  compatibility_flags: undefined | string[];
-  usage_model: undefined | "bundled" | "unbound";
-}
-
-/**
- * A stub to create a Cloudflare Worker preview.
- *
- * @example
- * const {value, host} = await createWorker(init, acct);
- */
-export async function createWorker(
-  init: CfWorkerInit,
-  account: CfAccount
-): Promise<CfPreviewToken> {
-  const token = await previewToken(account, init);
-  const response = await fetch(token.prewarmUrl.href, { method: "POST" });
-  if (!response.ok) {
-    // console.error("worker failed to prewarm: ", response.statusText);
-  }
-  return token;
-}

package/src/cfetch/index.ts

@@ -1,110 +0,0 @@
-import type { RequestInit } from "node-fetch";
-import { URLSearchParams } from "url";
-import { fetchInternal } from "./internal";
-
-// Check out https://api.cloudflare.com/ for API docs.
-
-export { CF_API_BASE_URL } 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;
-}
-
-/**
- * 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);
-}
-
-/**
- * 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 {
-  response.messages.forEach((message) => console.warn(message));
-  const errors = response.errors
-    .map((error) => `${error.code}: ${error.message}`)
-    .join("\n");
-  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: string } | undefined)?.cursor !== undefined;
-}