wrangler 0.0.0-e1c615f → 0.0.0-e3a458e

package/src/__tests__/run-in-tmp.ts

@@ -1,19 +0,0 @@
-import * as os from "node:os";
-import * as path from "node:path";
-import * as fs from "fs";
-
-const originalCwd = process.cwd();
-
-export function runInTempDir() {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wrangler-tests"));
-    process.chdir(tmpDir);
-  });
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-}

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/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/inspect.ts

@@ -1,430 +0,0 @@
-import { Response, Request, Headers } from "node-fetch";
-import type { MessageEvent } from "ws";
-import WebSocket, { WebSocketServer } from "ws";
-import type { IncomingMessage, ServerResponse } from "http";
-import { createServer } from "http";
-
-/**
- * A call frame.
- *
- * @link https://chromedevtools.github.io/devtools-protocol/1-3/Runtime/#type-CallFrame
- */
-export interface DtCallFrame {
-  /**
-   * The module path.
-   *
-   * @example
-   * 'worker.js'
-   */
-  url: string;
-  /**
-   * The function name.
-   */
-  functionName?: string;
-  /**
-   * The line number. (0-based)
-   */
-  lineNumber: number;
-  /**
-   * The column number. (0-based)
-   */
-  columnNumber: number;
-}
-
-/**
- * A stack trace.
- *
- * @link https://chromedevtools.github.io/devtools-protocol/1-3/Runtime/#type-StackTrace
- */
-export interface DtStackTrace {
-  /**
-   * A description of the stack, only present in certain contexts.
-   */
-  description?: string;
-  /**
-   * The call frames.
-   */
-  callFrames: DtCallFrame[];
-  /**
-   * The parent stack trace.
-   */
-  parent?: DtStackTrace;
-}
-
-/**
- * A JavaScript object type.
- */
-export type DtRemoteObjectType =
-  | "object"
-  | "function"
-  | "undefined"
-  | "string"
-  | "number"
-  | "boolean"
-  | "symbol"
-  | "bigint";
-
-/**
- * A view of a remote JavaScript object.
- *
- * @link https://chromedevtools.github.io/devtools-protocol/1-3/Runtime/#type-RemoteObject
- */
-export interface DtRemoteObject<T> {
-  /**
-   * The object type.
-   *
-   * @example
-   * 'string'
-   */
-  type: DtRemoteObjectType;
-  /**
-   * The specific object type, if the type is `object`.
-   *
-   * @example
-   * 'arraybuffer'
-   */
-  subtype?: string;
-  /**
-   * The class name, if the type if `object`.
-   */
-  className?: string;
-  /**
-   * The object as a string.
-   *
-   * @example
-   * 'Array(1)'
-   * 'TypeError: Oops!\n    at worker.js:5:15'
-   */
-  description?: string;
-  /**
-   * The object.
-   */
-  value?: T;
-  // TODO(soon): add a preview field for more complex types
-}
-
-/**
- * An event when `console.log()` is invoked.
- *
- * @link https://chromedevtools.github.io/devtools-protocol/1-3/Runtime/#event-consoleAPICalled
- */
-export interface DtLogEvent {
-  timestamp: number;
-  type: string;
-  args: DtRemoteObject<unknown>[];
-  stackTrace?: DtStackTrace;
-}
-
-/**
- * An event when an uncaught `Error` is thrown.
- *
- * @link https://chromedevtools.github.io/devtools-protocol/1-3/Runtime/#event-exceptionThrown
- */
-export interface DtExceptionEvent {
-  timestamp: number;
-  exceptionDetails: {
-    lineNumber: number;
-    columnNumber: number;
-    exception: DtRemoteObject<Error>;
-    stackTrace: DtStackTrace;
-  };
-}
-
-/**
- * A DevTools event.
- */
-export type DtEvent = DtLogEvent | DtExceptionEvent;
-
-/**
- * A listener that receives DevTools events.
- */
-export type DtListener = (event: DtEvent) => void;
-
-/**
- * A DevTools inspector that listens to logs and debug events from a Worker.
- *
- * @example
- * const worker: CfWorker
- * const inspector: DtInspector = await worker.inspect()
- *
- * @link https://chromedevtools.github.io/devtools-protocol/
- */
-export class DtInspector {
-  #webSocket: WebSocket;
-  #keepAlive?: NodeJS.Timer;
-
-  constructor(url: string) {
-    // this.#events = [];
-    // this.#listeners = [];
-    this.#webSocket = new WebSocket(url);
-    this.#webSocket.onopen = () => {
-      this.enable();
-    };
-    this.#webSocket.onclose = () => {
-      this.disable();
-    };
-    this.#webSocket.on("unexpected-response", () => {
-      console.log("504??"); // TODO: refactor this class to start again
-    });
-    this.#webSocket.onmessage = (event: MessageEvent) => {
-      // TODO: this seems unnecessary, unless we're planning
-      // on logging to console. We'll see.
-      if (typeof event.data === "string") {
-        // this.recv(JSON.parse(event.data));
-      } else {
-        // ??
-      }
-    };
-  }
-
-  /**
-   * Exposes a websocket proxy on a localhost port.
-   */
-  proxyTo(port: number): AbortController {
-    return bind(new DtInspectorBridge(this.#webSocket, port), port);
-  }
-
-  /**
-   * If the inspector is closed.
-   */
-  get closed(): boolean {
-    return this.#webSocket.readyState === WebSocket.CLOSED;
-  }
-
-  /**
-   * Closes the inspector.
-   */
-  close(): void {
-    if (!this.closed) {
-      try {
-        this.#webSocket.close();
-      } catch (err) {
-        // Closing before the websocket is ready will throw an error.
-      }
-    }
-    // this.#events = [];
-  }
-
-  private send(event: Record<string, unknown>): void {
-    if (!this.closed) {
-      this.#webSocket.send(JSON.stringify(event));
-    }
-  }
-
-  private enable(): void {
-    let id = 1;
-    this.send({ method: "Runtime.enable", id });
-    this.#keepAlive = setInterval(() => {
-      this.send({ method: "Runtime.getIsolateId", id: id++ });
-    }, 10_000);
-  }
-
-  private disable(): void {
-    if (this.#keepAlive) {
-      clearInterval(this.#keepAlive);
-      this.#keepAlive = undefined;
-    }
-  }
-}
-
-/**
- * A HTTP server that responds to `fetch()` requests.
- */
-interface FetchServer {
-  /**
-   * Responds to a request.
-   */
-  fetch(request: Request): Promise<Response>;
-  /**
-   * Accepts a websocket connection.
-   */
-  upgrade?(webSocket: WebSocket): void;
-}
-
-/**
- * A bridge between a remote DevTools inspector and Chrome.
- *
- * Exposes a localhost HTTP server that responds to informational requests
- * from Chrome about the DevTools inspector. Then, when it receives a
- * WebSocket upgrade, forwards the connection to the remote inspector.
- */
-class DtInspectorBridge implements FetchServer {
-  #webSocket: WebSocket;
-  #localPort: number;
-  #connected: boolean;
-
-  constructor(webSocket: WebSocket, localPort?: number) {
-    this.#webSocket = webSocket;
-    this.#localPort = localPort;
-    this.#connected = false;
-  }
-
-  async fetch(request: Request): Promise<Response> {
-    const { url } = request;
-    const { pathname } = new URL(url);
-    switch (pathname) {
-      case "/json/version":
-        return this.version;
-      case "/json":
-      case "/json/list":
-        return this.location;
-      default:
-        break;
-    }
-    return new Response("Not Found", { status: 404 });
-  }
-
-  upgrade(webSocket: WebSocket): void {
-    if (this.#connected) {
-      webSocket.close(
-        1013,
-        "Too many clients; only one can be connected at a time"
-      );
-    } else {
-      this.#connected = true;
-      webSocket.addEventListener("close", () => (this.#connected = false));
-      proxyWebSocket(webSocket, this.#webSocket);
-    }
-  }
-
-  private get version(): Response {
-    const headers = { "Content-Type": "application/json" };
-    const body = {
-      Browser: "workers-run/v0.0.0", // TODO: this should pick up version from package.json
-      // TODO: (someday): The DevTools protocol should match that of edgeworker.
-      // This could be exposed by the preview API.
-      "Protocol-Version": "1.3",
-    };
-    return new Response(JSON.stringify(body), { headers });
-  }
-
-  private get location(): Response {
-    const headers = { "Content-Type": "application/json" };
-    const localHost = `localhost:${this.#localPort}/ws`;
-    const devtoolsFrontendUrl = `devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws=${localHost}`;
-    const devtoolsFrontendUrlCompat = `devtools://devtools/bundled/inspector.html?experiments=true&v8only=true&ws=${localHost}`;
-    const body = [
-      {
-        id: randomId(),
-        type: "node",
-        description: "workers",
-        webSocketDebuggerUrl: `ws://${localHost}`,
-        devtoolsFrontendUrl,
-        devtoolsFrontendUrlCompat,
-        // Below are fields that are visible in the DevTools UI.
-        title: "Cloudflare Worker",
-        faviconUrl: "https://workers.cloudflare.com/favicon.ico",
-        url: "https://" + new URL(this.#webSocket.url).host,
-      },
-    ];
-    return new Response(JSON.stringify(body), { headers });
-  }
-}
-
-function bind(fetcher: FetchServer, port?: number): AbortController {
-  const controller = new AbortController();
-
-  const server = createServer(
-    (input: IncomingMessage, output: ServerResponse) =>
-      toRequest(input)
-        .then((request) => fetcher.fetch(request))
-        .then((response) => toResponse(response, output))
-        .catch((error) => console.error(error))
-  );
-
-  if (fetcher.upgrade) {
-    const webSocket = new WebSocketServer({ server });
-    webSocket.on("connection", (ws: WebSocket) => fetcher.upgrade(ws));
-  }
-
-  const socket = server.listen({ port });
-  controller.signal.onabort = () => {
-    server.close();
-    socket.close();
-  };
-  return controller;
-}
-
-/**
- * Converts a Node.js request to a Web standard `Request`.
- */
-async function toRequest(request: IncomingMessage): Promise<Request> {
-  const host = request.headers.host ?? "localhost";
-  const { href } = new URL(request.url, "http://" + host);
-
-  const { rawHeaders, method } = request;
-  const headers = new Headers();
-  for (let i = 0; i < rawHeaders.length; i += 2) {
-    headers.append(rawHeaders[i], rawHeaders[i + 1]);
-  }
-
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    request.on("data", (chunk) => chunks.push(chunk));
-    request.on("error", (error) => reject(error));
-    request.on("end", () => {
-      const buffer = Buffer.concat(chunks);
-      const body = buffer.length === 0 ? undefined : buffer;
-      resolve(new Request(href, { method, headers, body }));
-    });
-  });
-}
-
-/**
- * Converts a Web standard `Response` into a Node.js response.
- */
-async function toResponse(
-  input: Response,
-  response: ServerResponse
-): Promise<void> {
-  const { status, statusText, headers, body: hasBody } = input;
-
-  for (const [name, value] of headers.entries()) {
-    response.setHeader(name, value);
-  }
-
-  let body: Uint8Array;
-  if (hasBody) {
-    body = new Uint8Array(await input.arrayBuffer());
-    response.setHeader("Content-Length", body.byteLength);
-  }
-
-  response.writeHead(status, statusText);
-  response.write(body);
-}
-
-/**
- * Creates a proxy bridge between two websockets.
- */
-function proxyWebSocket(webSocket: WebSocket, otherSocket: WebSocket): void {
-  webSocket.addEventListener("message", (event: MessageEvent) => {
-    try {
-      otherSocket.send(event.data);
-    } catch (e) {
-      if (e.message !== "WebSocket is not open: readyState 0 (CONNECTING)") {
-        // this just means we haven't opened a websocket yet
-        // usually happens until there's at least one request
-        // which is weird, because we may miss something that happens on
-        // the first request
-        console.error(e);
-      }
-    }
-  });
-  otherSocket.addEventListener("message", (event: MessageEvent) =>
-    webSocket.send(event.data)
-  );
-
-  // Some close codes are marked as 'reserved' and will throw an error if used.
-  // Therefore, it's not worth the effort to passthrough the close code and reason.
-  webSocket.addEventListener("close", () => otherSocket.close());
-  otherSocket.addEventListener("close", () => webSocket.close());
-}
-
-// 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);
-  });
-}