wrangler 0.0.13 → 0.0.17

package/src/__tests__/tail.test.ts

@@ -0,0 +1,246 @@
+import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
+import { setMockResponse } from "./helpers/mock-cfetch";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { WS } from "./helpers/mock-web-socket";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+import type Websocket from "ws";
+
+// change this if you're testing using debug mode
+// (sends all logs regardless of filters)
+const DEBUG = false;
+
+describe("tail", () => {
+  runInTempDir();
+  mockAccountId();
+  mockApiToken();
+
+  const std = mockConsoleMethods();
+  const api = mockWebsocketApis();
+
+  /* API related functionality */
+
+  it("creates and then delete tails", async () => {
+    expect(api.requests.creation.count).toStrictEqual(0);
+
+    await runWrangler("tail test-worker");
+
+    await expect(api.ws.connected).resolves.toBeTruthy();
+    expect(api.requests.creation.count).toStrictEqual(1);
+    expect(api.requests.deletion.count).toStrictEqual(0);
+
+    api.ws.close();
+    expect(api.requests.deletion.count).toStrictEqual(1);
+  });
+
+  /* filtering */
+
+  it("sends sampling rate filters", async () => {
+    const tooHigh = runWrangler("tail test-worker --sampling-rate 10");
+    await expect(tooHigh).rejects.toThrow();
+
+    const tooLow = runWrangler("tail test-worker --sampling-rate -5");
+    await expect(tooLow).rejects.toThrow();
+
+    await runWrangler("tail test-worker --sampling-rate 0.25");
+    await expect(api.ws.nextMessageJson()).resolves.toHaveProperty("filters", [
+      { sampling_rate: 0.25 },
+    ]);
+  });
+
+  it("sends single status filters", async () => {
+    await runWrangler("tail test-worker --status error");
+    await expect(api.ws.nextMessageJson()).resolves.toHaveProperty("filters", [
+      { outcome: ["exception", "exceededCpu", "unknown"] },
+    ]);
+  });
+
+  it("sends multiple status filters", async () => {
+    await runWrangler("tail test-worker --status error --status canceled");
+    await expect(api.ws.nextMessageJson()).resolves.toHaveProperty("filters", [
+      { outcome: ["exception", "exceededCpu", "unknown", "canceled"] },
+    ]);
+  });
+
+  it("sends single HTTP method filters", async () => {
+    await runWrangler("tail test-worker --method POST");
+    await expect(api.ws.nextMessageJson()).resolves.toHaveProperty("filters", [
+      { method: ["POST"] },
+    ]);
+  });
+
+  it("sends multiple HTTP method filters", async () => {
+    await runWrangler("tail test-worker --method POST --method GET");
+    await expect(api.ws.nextMessageJson()).resolves.toHaveProperty("filters", [
+      { method: ["POST", "GET"] },
+    ]);
+  });
+
+  it("sends header filters without a query", async () => {
+    await runWrangler("tail test-worker --header X-CUSTOM-HEADER ");
+    await expect(api.ws.nextMessageJson()).resolves.toHaveProperty("filters", [
+      { header: { key: "X-CUSTOM-HEADER" } },
+    ]);
+  });
+
+  it("sends header filters with a query", async () => {
+    await runWrangler("tail test-worker --header X-CUSTOM-HEADER:some-value ");
+    await expect(api.ws.nextMessageJson()).resolves.toHaveProperty("filters", [
+      { header: { key: "X-CUSTOM-HEADER", query: "some-value" } },
+    ]);
+  });
+
+  it("sends single IP filters", async () => {
+    const fakeIp = "192.0.2.1";
+
+    await runWrangler(`tail test-worker --ip ${fakeIp}`);
+    await expect(api.ws.nextMessageJson()).resolves.toHaveProperty("filters", [
+      { client_ip: [fakeIp] },
+    ]);
+  });
+
+  it("sends multiple IP filters", async () => {
+    const fakeIp = "192.0.2.1";
+
+    await runWrangler(`tail test-worker --ip ${fakeIp} --ip self`);
+    await expect(api.ws.nextMessageJson()).resolves.toHaveProperty("filters", [
+      { client_ip: [fakeIp, "self"] },
+    ]);
+  });
+
+  it("sends search filters", async () => {
+    const search = "filterMe";
+
+    await runWrangler(`tail test-worker --search ${search}`);
+    await expect(api.ws.nextMessageJson()).resolves.toHaveProperty("filters", [
+      { query: search },
+    ]);
+  });
+
+  it("sends everything but the kitchen sink", async () => {
+    const sampling_rate = 0.69;
+    const status = ["ok", "error"];
+    const method = ["GET", "POST", "PUT"];
+    const header = "X-HELLO:world";
+    const client_ip = ["192.0.2.1", "self"];
+    const query = "onlyTheseMessagesPlease";
+
+    const cliFilters =
+      `--sampling-rate ${sampling_rate} ` +
+      status.map((s) => `--status ${s} `).join("") +
+      method.map((m) => `--method ${m} `).join("") +
+      `--header ${header} ` +
+      client_ip.map((c) => `--ip ${c} `).join("") +
+      `--search ${query}`;
+
+    const expectedWebsocketMessage = {
+      filters: [
+        { sampling_rate },
+        { outcome: ["ok", "exception", "exceededCpu", "unknown"] },
+        { method },
+        { header: { key: "X-HELLO", query: "world" } },
+        { client_ip },
+        { query },
+      ],
+      debug: DEBUG,
+    };
+
+    await runWrangler(`tail test-worker ${cliFilters}`);
+    await expect(api.ws.nextMessageJson()).resolves.toEqual(
+      expectedWebsocketMessage
+    );
+  });
+
+  /* Basic logging */
+
+  it("logs incoming messages", async () => {
+    await runWrangler("tail test-worker");
+    const greeting = serialize({ hello: "world!" });
+    api.ws.send(greeting);
+    expect(std.out).toMatch(deserializeToJson(greeting));
+  });
+});
+
+/* helpers */
+
+function serialize(message: unknown): Websocket.RawData {
+  return Buffer.from(JSON.stringify(message), "utf-8");
+}
+
+function deserializeToJson(message: Websocket.RawData): string {
+  return JSON.stringify(JSON.parse(message.toString()), null, 2);
+}
+
+type RequestCounter = {
+  count: number;
+};
+
+function mockCreateTailRequest(websocketURL: string): RequestCounter {
+  const requests = { count: 0 };
+  setMockResponse(
+    "/accounts/:accountId/workers/scripts/:worker/tails",
+    "POST",
+    () => {
+      requests.count++;
+      return {
+        id: "tail-id",
+        url: websocketURL,
+        expires_at: new Date(3005, 0, 0),
+      };
+    }
+  );
+
+  return requests;
+}
+
+function mockDeleteTailRequest(): RequestCounter {
+  const requests = { count: 0 };
+  setMockResponse(
+    "/accounts/:accountId/workers/scripts/:worker/tails/:tailId",
+    "DELETE",
+    () => {
+      requests.count++;
+      return null;
+    }
+  );
+
+  return requests;
+}
+
+type MockAPI = {
+  requests: {
+    creation: RequestCounter;
+    deletion: RequestCounter;
+  };
+  ws: WS;
+};
+
+function mockWebsocketApis(websocketURL = "ws://localhost:1234"): MockAPI {
+  const api: MockAPI = {
+    requests: {
+      deletion: { count: 0 },
+      creation: { count: 0 },
+    },
+    ws: new WS(websocketURL),
+  };
+
+  // don't delete this line or else it breaks.
+  // we need to have api.ws be an instasnce of WS for
+  // the type checker to be happy, but if we have
+  // an actual open websocket then it causes problems
+  // since we create a new websocket beforeEach test.
+  // so we need to close it before we ever use it.
+  api.ws.close();
+
+  beforeEach(() => {
+    api.requests.creation = mockCreateTailRequest(websocketURL);
+    api.requests.deletion = mockDeleteTailRequest();
+    api.ws = new WS(websocketURL);
+  });
+
+  afterEach(() => {
+    api.ws.close();
+  });
+
+  return api;
+}

package/src/__tests__/whoami.test.tsx

@@ -1,32 +1,15 @@
-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 React from "react";
 import { initialise } from "../user";
-
-const ORIGINAL_CF_API_TOKEN = process.env.CF_API_TOKEN;
-const ORIGINAL_CF_ACCOUNT_ID = process.env.CF_ACCOUNT_ID;
+import { getUserInfo, WhoAmI } from "../whoami";
+import { setMockResponse } from "./helpers/mock-cfetch";
+import { writeUserConfig } from "./helpers/mock-user";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import type { UserInfo } from "../whoami";
 
 describe("getUserInfo()", () => {
   runInTempDir({ homedir: "./home" });
 
-  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;
-  });
-
-  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();
@@ -101,27 +84,3 @@ describe("WhoAmI component", () => {
     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,10 +1,10 @@
+import { readFileSync } from "node:fs";
+import { FormData, File } from "undici";
 import type {
   CfWorkerInit,
   CfModuleType,
-  CfModule,
   CfDurableObjectMigrations,
 } from "./worker.js";
-import { FormData, Blob } from "formdata-node";
 
 export function toMimeType(type: CfModuleType): string {
   switch (type) {
@@ -23,14 +23,11 @@ export function toMimeType(type: CfModuleType): string {
   }
 }
 
-function toModule(module: CfModule, entryType: CfModuleType): Blob {
-  const { type: moduleType, content } = module;
-  const type = toMimeType(moduleType ?? entryType);
-
-  return new Blob([content], { type });
-}
-
-interface WorkerMetadata {
+export interface WorkerMetadata {
+  /** The name of the entry point module. Only exists when the worker is in the ES module format */
+  main_module?: string;
+  /** The name of the entry point module. Only exists when the worker is in the Service Worker format */
+  body_part?: string;
   compatibility_date?: string;
   compatibility_flags?: string[];
   usage_model?: "bundled" | "unbound";
@@ -38,18 +35,15 @@ interface WorkerMetadata {
   bindings: (
     | { type: "kv_namespace"; name: string; namespace_id: string }
     | { type: "plain_text"; name: string; text: string }
+    | { type: "json"; name: string; json: unknown }
+    | { type: "wasm_module"; name: string; part: string }
     | {
         type: "durable_object_namespace";
         name: string;
         class_name: string;
         script_name?: string;
       }
-    | {
-        type: "service";
-        name: string;
-        service: string;
-        environment: string;
-      }
+    | { type: "r2_bucket"; name: string; bucket_name: string }
   )[];
 }
 
@@ -89,18 +83,71 @@ export function toFormData(worker: CfWorkerInit): FormData {
     }
   );
 
+  bindings.r2_buckets?.forEach(({ binding, bucket_name }) => {
+    metadataBindings.push({
+      name: binding,
+      type: "r2_bucket",
+      bucket_name,
+    });
+  });
+
   Object.entries(bindings.vars || {})?.forEach(([key, value]) => {
-    metadataBindings.push({ name: key, type: "plain_text", text: value });
+    if (typeof value === "string") {
+      metadataBindings.push({ name: key, type: "plain_text", text: value });
+    } else {
+      metadataBindings.push({ name: key, type: "json", json: value });
+    }
   });
 
-  bindings.services?.forEach(({ name, service, environment }) => {
+  for (const [name, filePath] of Object.entries(bindings.wasm_modules || {})) {
     metadataBindings.push({
       name,
-      type: "service",
-      service,
-      environment,
+      type: "wasm_module",
+      part: name,
     });
-  });
+
+    formData.set(
+      name,
+      new File([readFileSync(filePath)], filePath, {
+        type: "application/wasm",
+      })
+    );
+  }
+
+  if (main.type === "commonjs") {
+    // This is a service-worker format worker.
+    // So we convert all `.wasm` modules into `wasm_module` bindings.
+    for (const [index, module] of Object.entries(modules || [])) {
+      if (module.type === "compiled-wasm") {
+        // The "name" of the module is a file path. We use it
+        // to instead be a "part" of the body, and a reference
+        // that we can use inside our source. This identifier has to be a valid
+        // JS identifier, so we replace all non alphanumeric characters
+        // with an underscore.
+        const name = module.name.replace(/[^a-zA-Z0-9_$]/g, "_");
+        metadataBindings.push({
+          name,
+          type: "wasm_module",
+          part: name,
+        });
+
+        // Add the module to the form data.
+        formData.set(
+          name,
+          new File([module.content], module.name, {
+            type: "application/wasm",
+          })
+        );
+        // And then remove it from the modules collection
+        modules?.splice(parseInt(index, 10), 1);
+      }
+    }
+  }
+
+  if (bindings.unsafe) {
+    // @ts-expect-error unsafe bindings don't need to match a specific type here
+    metadataBindings.push(...bindings.unsafe);
+  }
 
   const metadata: WorkerMetadata = {
     ...(main.type !== "commonjs"
@@ -122,9 +169,12 @@ export function toFormData(worker: CfWorkerInit): FormData {
   }
 
   for (const module of [main].concat(modules || [])) {
-    const { name } = module;
-    const blob = toModule(module, main.type ?? "esm");
-    formData.set(name, blob, name);
+    formData.set(
+      module.name,
+      new File([module.content], module.name, {
+        type: toMimeType(module.type ?? main.type ?? "esm"),
+      })
+    );
   }
 
   return formData;

package/src/api/preview.ts

@@ -1,4 +1,5 @@
-import fetch from "node-fetch";
+import { URL } from "node:url";
+import { fetch } from "undici";
 import { fetchResult } from "../cfetch";
 import { toFormData } from "./form_data";
 import type { CfAccount, CfWorkerInit } from "./worker";
@@ -108,7 +109,6 @@ export async function previewToken(
 
   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,

package/src/api/worker.ts

@@ -1,6 +1,6 @@
-import type { CfPreviewToken } from "./preview";
+import { fetch } from "undici";
 import { previewToken } from "./preview";
-import fetch from "node-fetch";
+import type { CfPreviewToken } from "./preview";
 
 /**
  * A Cloudflare account.
@@ -22,6 +22,11 @@ export interface CfAccount {
   zoneId?: string;
 }
 
+/**
+ * The type of Worker
+ */
+export type CfScriptFormat = "modules" | "service-worker";
+
 /**
  * A module type.
  */
@@ -53,7 +58,7 @@ export interface CfModule {
    *   }
    * }
    */
-  content: string | BufferSource;
+  content: string | Buffer;
   /**
    * The module type.
    *
@@ -66,7 +71,7 @@ export interface CfModule {
  * A map of variable names to values.
  */
 interface CfVars {
-  [key: string]: string;
+  [key: string]: unknown;
 }
 
 /**
@@ -77,6 +82,14 @@ interface CfKvNamespace {
   id: string;
 }
 
+/**
+ * A binding to a wasm module (in service worker format)
+ */
+
+interface CfWasmModuleBindings {
+  [key: string]: string;
+}
+
 /**
  * A Durable Object.
  */
@@ -86,13 +99,14 @@ interface CfDurableObject {
   script_name?: string;
 }
 
-/**
- * A Service.
- */
-interface CfService {
+interface CfR2Bucket {
+  binding: string;
+  bucket_name: string;
+}
+
+interface CfUnsafeBinding {
   name: string;
-  service: string;
-  environment: string;
+  type: string;
 }
 
 export interface CfDurableObjectMigrations {
@@ -100,7 +114,10 @@ export interface CfDurableObjectMigrations {
   new_tag: string;
   steps: {
     new_classes?: string[];
-    renamed_classes?: string[];
+    renamed_classes?: {
+      from: string;
+      to: string;
+    }[];
     deleted_classes?: string[];
   }[];
 }
@@ -125,10 +142,12 @@ export interface CfWorkerInit {
    * All the bindings
    */
   bindings: {
-    kv_namespaces?: CfKvNamespace[];
-    durable_objects?: { bindings: CfDurableObject[] };
-    vars?: CfVars;
-    services?: CfService[];
+    vars: CfVars | undefined;
+    kv_namespaces: CfKvNamespace[] | undefined;
+    wasm_modules: CfWasmModuleBindings | undefined;
+    durable_objects: { bindings: CfDurableObject[] } | undefined;
+    r2_buckets: CfR2Bucket[] | undefined;
+    unsafe: CfUnsafeBinding[] | undefined;
   };
   migrations: undefined | CfDurableObjectMigrations;
   compatibility_date: string | undefined;

package/src/bundle.ts

@@ -0,0 +1,127 @@
+import assert from "node:assert";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as esbuild from "esbuild";
+import makeModuleCollector from "./module-collection";
+import type { CfModule, CfScriptFormat } from "./api/worker";
+
+/**
+ * An entry point for the worker. It consists not just of a `file`,
+ * but also of a `directory` that is used to resolve relative paths.
+ */
+export type Entry = { file: string; directory: string };
+
+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,
+  serveAssetsFromWorker: boolean,
+  destination: string,
+  jsxFactory: string | undefined,
+  jsxFragment: string | undefined,
+  format: CfScriptFormat,
+  watch?: esbuild.WatchMode
+): Promise<BundleResult> {
+  const moduleCollector = makeModuleCollector({ format });
+  const result = await esbuild.build({
+    ...getEntryPoint(entry.file, serveAssetsFromWorker),
+    bundle: true,
+    absWorkingDir: entry.directory,
+    outdir: destination,
+    external: ["__STATIC_CONTENT_MANIFEST"],
+    format: "esm",
+    sourcemap: true,
+    metafile: true,
+    conditions: ["worker", "browser"],
+    loader: {
+      ".js": "jsx",
+      ".html": "text",
+      ".pem": "text",
+      ".txt": "text",
+    },
+    plugins: [moduleCollector.plugin],
+    ...(jsxFactory && { jsxFactory }),
+    ...(jsxFragment && { jsxFragment }),
+    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];