wrangler 0.0.0-ece06ea → 0.0.0-edc4b53

package/pages/functions/template-worker.ts

@@ -0,0 +1,144 @@
+import { match } from "path-to-regexp";
+import type { HTTPMethod } from "./routes";
+
+/* TODO: Grab these from @cloudflare/workers-types instead */
+type Params<P extends string = string> = Record<P, string | string[]>;
+
+type EventContext<Env, P extends string, Data> = {
+  request: Request;
+  waitUntil: (promise: Promise<unknown>) => void;
+  next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
+  env: Env & { ASSETS: { fetch: typeof fetch } };
+  params: Params<P>;
+  data: Data;
+};
+
+declare type PagesFunction<
+  Env = unknown,
+  P extends string = string,
+  Data extends Record<string, unknown> = Record<string, unknown>
+> = (context: EventContext<Env, P, Data>) => Response | Promise<Response>;
+/* end @cloudflare/workers-types */
+
+type RouteHandler = {
+  routePath: string;
+  methods: HTTPMethod[];
+  modules: PagesFunction[];
+  middlewares: PagesFunction[];
+};
+
+// inject `routes` via ESBuild
+declare const routes: RouteHandler[];
+// define `__FALLBACK_SERVICE__` via ESBuild
+declare const __FALLBACK_SERVICE__: string;
+
+// expect an ASSETS fetcher binding pointing to the asset-server stage
+type Env = {
+  [name: string]: unknown;
+  ASSETS: { fetch(url: string, init: RequestInit): Promise<Response> };
+};
+
+type WorkerContext = {
+  waitUntil: (promise: Promise<unknown>) => void;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- `env` can be used by __FALLBACK_SERVICE_FETCH__
+function* executeRequest(request: Request, env: Env) {
+  const requestPath = new URL(request.url).pathname;
+
+  // First, iterate through the routes (backwards) and execute "middlewares" on partial route matches
+  for (const route of [...routes].reverse()) {
+    if (
+      route.methods.length &&
+      !route.methods.includes(request.method as HTTPMethod)
+    ) {
+      continue;
+    }
+
+    const routeMatcher = match(route.routePath, { end: false });
+    const matchResult = routeMatcher(requestPath);
+    if (matchResult) {
+      for (const handler of route.middlewares.flat()) {
+        yield {
+          handler,
+          params: matchResult.params as Params,
+        };
+      }
+    }
+  }
+
+  // Then look for the first exact route match and execute its "modules"
+  for (const route of routes) {
+    if (
+      route.methods.length &&
+      !route.methods.includes(request.method as HTTPMethod)
+    ) {
+      continue;
+    }
+
+    const routeMatcher = match(route.routePath, { end: true });
+    const matchResult = routeMatcher(requestPath);
+    if (matchResult && route.modules.length) {
+      for (const handler of route.modules.flat()) {
+        yield {
+          handler,
+          params: matchResult.params as Params,
+        };
+      }
+      break;
+    }
+  }
+
+  // Finally, yield to the fallback service (`env.ASSETS.fetch` in Pages' case)
+  return {
+    handler: () =>
+      __FALLBACK_SERVICE__
+        ? // @ts-expect-error expecting __FALLBACK_SERVICE__ to be the name of a service binding, so fetch should be defined
+          env[__FALLBACK_SERVICE__].fetch(request)
+        : fetch(request),
+    params: {} as Params,
+  };
+}
+
+export default {
+  async fetch(request: Request, env: Env, workerContext: WorkerContext) {
+    const handlerIterator = executeRequest(request, env);
+    const data = {}; // arbitrary data the user can set between functions
+    const next = async (input?: RequestInfo, init?: RequestInit) => {
+      if (input !== undefined) {
+        request = new Request(input, init);
+      }
+
+      const { value } = handlerIterator.next();
+      if (value) {
+        const { handler, params } = value;
+        const context: EventContext<
+          unknown,
+          string,
+          Record<string, unknown>
+        > = {
+          request: new Request(request.clone()),
+          next,
+          params,
+          data,
+          env,
+          waitUntil: workerContext.waitUntil.bind(workerContext),
+        };
+
+        const response = await handler(context);
+
+        // https://fetch.spec.whatwg.org/#null-body-status
+        return new Response(
+          [101, 204, 205, 304].includes(response.status) ? null : response.body,
+          response
+        );
+      }
+    };
+
+    try {
+      return next();
+    } catch (err) {
+      return new Response("Internal Error", { status: 500 });
+    }
+  },
+};

package/src/__tests__/dev.test.tsx

@@ -0,0 +1,66 @@
+import { render } from "ink-testing-library";
+import patchConsole from "patch-console";
+import React from "react";
+import Dev from "../dev";
+import type { DevProps } from "../dev";
+
+describe("Dev component", () => {
+  let restoreConsole;
+  beforeEach(() => (restoreConsole = patchConsole(() => {})));
+  afterEach(() => restoreConsole());
+
+  it("should throw if format is service-worker and there is a public directory", () => {
+    const { lastFrame } = renderDev({
+      format: "service-worker",
+      accountId: "some-account-id",
+      public: "some/public/path",
+    });
+    expect(lastFrame()).toMatchInlineSnapshot(`
+      "Something went wrong:
+      You cannot use the service worker format with a \`public\` directory."
+    `);
+  });
+});
+
+/**
+ * Helper function to make it easier to setup and render the `Dev` component.
+ *
+ * All the `Dev` props are optional here, with sensible defaults for testing.
+ */
+function renderDev({
+  name,
+  entry = "some/entry.ts",
+  port,
+  format,
+  accountId,
+  initialMode = "remote",
+  jsxFactory,
+  jsxFragment,
+  bindings = {},
+  public: publicDir,
+  site,
+  compatibilityDate,
+  compatibilityFlags,
+  usageModel,
+  buildCommand = {},
+}: Partial<DevProps>) {
+  return render(
+    <Dev
+      name={name}
+      entry={entry}
+      port={port}
+      buildCommand={buildCommand}
+      format={format}
+      initialMode={initialMode}
+      jsxFactory={jsxFactory}
+      jsxFragment={jsxFragment}
+      accountId={accountId}
+      site={site}
+      public={publicDir}
+      compatibilityDate={compatibilityDate}
+      compatibilityFlags={compatibilityFlags}
+      usageModel={usageModel}
+      bindings={bindings}
+    />
+  );
+}

package/src/__tests__/index.test.ts

@@ -1,153 +1,287 @@
-import * as fs from "node:fs";
 import * as fsp from "node:fs/promises";
-import * as path from "node:path";
 import * as TOML from "@iarna/toml";
-import { main } from "../index";
-// @ts-expect-error we're mocking cfetch, so of course setMock isn't a thing
-import { setMock, unsetAllMocks } from "../cfetch";
+import { mockConfirm } from "./mock-dialogs";
+import { runWrangler } from "./run-wrangler";
+import { runInTempDir } from "./run-in-tmp";
+import * as fs from "node:fs";
 
-jest.mock("../cfetch", () => {
-  return jest.requireActual("./mock-cfetch");
-});
+describe("wrangler", () => {
+  runInTempDir();
 
-async function w(cmd: void | string, options?: { tap: boolean }) {
-  const tapped = options?.tap ? tap() : undefined;
-  await main([...(cmd ? cmd.split(" ") : [])]);
-  tapped?.off();
-  return { stdout: tapped?.out, stderr: tapped?.err };
-}
-
-function tap() {
-  const oldLog = console.log;
-  const oldError = console.error;
-
-  const toReturn = {
-    off: () => {
-      console.log = oldLog;
-      console.error = oldError;
-    },
-    out: "",
-    err: "",
-  };
-
-  console.log = (...args) => {
-    toReturn.out += args.join("");
-    oldLog.apply(console, args);
-    // console.trace(...args); // use this if you want to find the true source of your console.log
-  };
-  console.error = (...args) => {
-    toReturn.err += args.join("");
-    oldError.apply(console, args);
-  };
-
-  return toReturn;
-}
+  describe("no command", () => {
+    it("should display a list of available commands", async () => {
+      const { stdout, stderr } = await runWrangler();
 
-describe("wrangler", () => {
-  it("should run", async () => {
-    const { stdout } = await w(undefined, { tap: true });
-
-    expect(stdout).toMatchInlineSnapshot(`
-      "wrangler
-
-      Commands:
-        wrangler init [name]       📥 Create a wrangler.toml configuration file
-        wrangler dev <filename>    👂 Start a local server for developing your worker
-        wrangler publish [script]  🆙 Publish your Worker to Cloudflare.
-        wrangler tail [name]       🦚 Starts a log tailing session for a deployed Worker.
-        wrangler secret            🤫 Generate a secret that can be referenced in the worker script
-        wrangler kv:namespace      🗂️  Interact with your Workers KV Namespaces
-        wrangler kv:key            🔑 Individually manage Workers KV key-value pairs
-        wrangler kv:bulk           💪 Interact with multiple Workers KV key-value pairs at once
-        wrangler pages             ⚡️ Configure Cloudflare Pages
-
-      Flags:
-        --config   Path to .toml configuration file  [string]
-        --help     Show help  [boolean]
-        --version  Show version number  [boolean]
-
-      Options:
-        --local  Run on my machine  [boolean] [default: false]"
-    `);
-  });
+      expect(stdout).toMatchInlineSnapshot(`
+        "wrangler
 
-  describe("init", () => {
-    const ogcwd = process.cwd();
+        Commands:
+          wrangler init [name]       📥 Create a wrangler.toml configuration file
+          wrangler dev <filename>    👂 Start a local server for developing your worker
+          wrangler publish [script]  🆙 Publish your Worker to Cloudflare.
+          wrangler tail [name]       🦚 Starts a log tailing session for a deployed Worker.
+          wrangler secret            🤫 Generate a secret that can be referenced in the worker script
+          wrangler kv:namespace      🗂️  Interact with your Workers KV Namespaces
+          wrangler kv:key            🔑 Individually manage Workers KV key-value pairs
+          wrangler kv:bulk           💪 Interact with multiple Workers KV key-value pairs at once
+          wrangler pages             ⚡️ Configure Cloudflare Pages
+
+        Flags:
+          -c, --config   Path to .toml configuration file  [string]
+          -h, --help     Show help  [boolean]
+          -v, --version  Show version number  [boolean]
+
+        Options:
+          -l, --local  Run on my machine  [boolean] [default: false]"
+      `);
 
-    beforeEach(() => {
-      process.chdir(path.join(__dirname, "fixtures", "init"));
+      expect(stderr).toMatchInlineSnapshot(`""`);
     });
+  });
+
+  describe("invalid command", () => {
+    it("should display an error", async () => {
+      const { error, stdout, stderr } = await runWrangler("invalid-command");
+
+      expect(stdout).toMatchInlineSnapshot(`""`);
+      expect(stderr).toMatchInlineSnapshot(`
+        "wrangler
+
+        Commands:
+          wrangler init [name]       📥 Create a wrangler.toml configuration file
+          wrangler dev <filename>    👂 Start a local server for developing your worker
+          wrangler publish [script]  🆙 Publish your Worker to Cloudflare.
+          wrangler tail [name]       🦚 Starts a log tailing session for a deployed Worker.
+          wrangler secret            🤫 Generate a secret that can be referenced in the worker script
+          wrangler kv:namespace      🗂️  Interact with your Workers KV Namespaces
+          wrangler kv:key            🔑 Individually manage Workers KV key-value pairs
+          wrangler kv:bulk           💪 Interact with multiple Workers KV key-value pairs at once
+          wrangler pages             ⚡️ Configure Cloudflare Pages
 
-    afterEach(async () => {
-      await fsp.rm("./wrangler.toml");
-      process.chdir(ogcwd);
+        Flags:
+          -c, --config   Path to .toml configuration file  [string]
+          -h, --help     Show help  [boolean]
+          -v, --version  Show version number  [boolean]
+
+        Options:
+          -l, --local  Run on my machine  [boolean] [default: false]
+
+        Unknown command: invalid-command."
+      `);
+      expect(error).toMatchInlineSnapshot(
+        `[Error: Unknown command: invalid-command.]`
+      );
     });
+  });
 
+  describe("init", () => {
     it("should create a wrangler.toml", async () => {
-      await w("init");
+      mockConfirm({
+        text: "No package.json found. Would you like to create one?",
+        result: false,
+      });
+      await runWrangler("init");
       const parsed = TOML.parse(await fsp.readFile("./wrangler.toml", "utf-8"));
       expect(typeof parsed.compatibility_date).toBe("string");
+      expect(fs.existsSync("./package.json")).toBe(false);
+      expect(fs.existsSync("./tsconfig.json")).toBe(false);
     });
 
-    it("should error when wrangler.toml already exists", async () => {
-      fs.closeSync(fs.openSync("./wrangler.toml", "w"));
-      const { stderr } = await w("init", { tap: true });
-      expect(stderr.endsWith("wrangler.toml already exists.")).toBe(true);
+    it("should display warning when wrangler.toml already exists, and exit if user does not want to carry on", async () => {
+      fs.writeFileSync("./wrangler.toml", "", "utf-8");
+      mockConfirm({
+        text: "Do you want to continue initializing this project?",
+        result: false,
+      });
+      const { warnings } = await runWrangler("init");
+      expect(warnings).toContain("wrangler.toml file already exists!");
+      const parsed = TOML.parse(await fsp.readFile("./wrangler.toml", "utf-8"));
+      expect(typeof parsed.compatibility_date).toBe("undefined");
     });
-  });
 
-  describe("kv:namespace", () => {
-    afterAll(() => {
-      unsetAllMocks();
+    it("should display warning when wrangler.toml already exists, but continue if user does want to carry on", async () => {
+      fs.writeFileSync("./wrangler.toml", "", "utf-8");
+      mockConfirm(
+        {
+          text: "Do you want to continue initializing this project?",
+          result: true,
+        },
+        {
+          text: "No package.json found. Would you like to create one?",
+          result: false,
+        }
+      );
+      const { warnings } = await runWrangler("init");
+      expect(warnings).toContain("wrangler.toml file already exists!");
+      const parsed = TOML.parse(await fsp.readFile("./wrangler.toml", "utf-8"));
+      expect(typeof parsed.compatibility_date).toBe("string");
+    });
+
+    it("should create a package.json if none is found and user confirms", async () => {
+      mockConfirm(
+        {
+          text: "No package.json found. Would you like to create one?",
+          result: true,
+        },
+        {
+          text: "Would you like to use typescript?",
+          result: false,
+        }
+      );
+      await runWrangler("init");
+      expect(fs.existsSync("./package.json")).toBe(true);
+      const packageJson = JSON.parse(
+        fs.readFileSync("./package.json", "utf-8")
+      );
+      expect(packageJson.name).toEqual("worker"); // TODO: should we infer the name from the directory?
+      expect(packageJson.version).toEqual("0.0.1");
+      expect(fs.existsSync("./tsconfig.json")).toBe(false);
+    });
+
+    it("should not touch an existing package.json in the same directory", async () => {
+      mockConfirm({
+        text: "Would you like to use typescript?",
+        result: false,
+      });
+
+      fs.writeFileSync(
+        "./package.json",
+        JSON.stringify({ name: "test", version: "1.0.0" }),
+        "utf-8"
+      );
+
+      await runWrangler("init");
+      const packageJson = JSON.parse(
+        fs.readFileSync("./package.json", "utf-8")
+      );
+      expect(packageJson.name).toEqual("test");
+      expect(packageJson.version).toEqual("1.0.0");
     });
-    let KVNamespaces: { title: string; id: string }[] = [];
-    it("can create a namespace", async () => {
-      setMock("/accounts/:accountId/storage/kv/namespaces", (uri, init) => {
-        expect(init.method === "POST");
-        const body = JSON.parse(init.body);
-        expect(body.title).toBe("worker-UnitTestNamespace");
-        KVNamespaces.push({ title: body.title, id: "some-namespace-id" });
-        return { id: "some-namespace-id" };
+
+    it("should not touch an existing package.json in an ancestor directory", async () => {
+      mockConfirm({
+        text: "Would you like to use typescript?",
+        result: false,
       });
 
-      await w("kv:namespace create UnitTestNamespace");
-      expect(
-        KVNamespaces.find((ns) => ns.title === `worker-UnitTestNamespace`)
-      ).toBeTruthy();
+      fs.writeFileSync(
+        "./package.json",
+        JSON.stringify({ name: "test", version: "1.0.0" }),
+        "utf-8"
+      );
+
+      fs.mkdirSync("./sub-1/sub-2", { recursive: true });
+      process.chdir("./sub-1/sub-2");
+
+      await runWrangler("init");
+      expect(fs.existsSync("./package.json")).toBe(false);
+      expect(fs.existsSync("../../package.json")).toBe(true);
+
+      const packageJson = JSON.parse(
+        fs.readFileSync("../../package.json", "utf-8")
+      );
+      expect(packageJson.name).toEqual("test");
+      expect(packageJson.version).toEqual("1.0.0");
     });
 
-    let createdNamespace: { id: string; title: string };
-    it("can list namespaces", async () => {
-      setMock(
-        "/accounts/:accountId/storage/kv/namespaces\\?:qs",
-        (uri, init) => {
-          expect(init).toBe(undefined);
-          return KVNamespaces;
+    it("should create a tsconfig.json and install `workers-types` if none is found and user confirms", async () => {
+      mockConfirm(
+        {
+          text: "No package.json found. Would you like to create one?",
+          result: true,
+        },
+        {
+          text: "Would you like to use typescript?",
+          result: true,
         }
       );
-      const { stdout } = await w("kv:namespace list", { tap: true });
-      const namespaces = JSON.parse(stdout);
-      createdNamespace = namespaces.find(
-        (ns) => ns.title === "worker-UnitTestNamespace"
+      await runWrangler("init");
+      expect(fs.existsSync("./tsconfig.json")).toBe(true);
+      const tsconfigJson = JSON.parse(
+        fs.readFileSync("./tsconfig.json", "utf-8")
+      );
+      expect(tsconfigJson.compilerOptions.types).toEqual([
+        "@cloudflare/workers-types",
+      ]);
+      const packageJson = JSON.parse(
+        fs.readFileSync("./package.json", "utf-8")
       );
-      expect(createdNamespace.title).toBe("worker-UnitTestNamespace");
+      expect(packageJson.devDependencies).toEqual({
+        "@cloudflare/workers-types": expect.any(String),
+      });
     });
 
-    it("can delete a namespace", async () => {
-      const namespaceIdToDelete = createdNamespace.id;
-      setMock(
-        "/accounts/:accountId/storage/kv/namespaces/:namespaceId",
-        (uri, init) => {
-          expect(init.method).toBe("DELETE");
-          KVNamespaces = KVNamespaces.filter(
-            (ns) => ns.id !== namespaceIdToDelete
-          );
-        }
+    it("should not touch an existing tsconfig.json in the same directory", async () => {
+      fs.writeFileSync(
+        "./package.json",
+        JSON.stringify({ name: "test", version: "1.0.0" }),
+        "utf-8"
+      );
+      fs.writeFileSync(
+        "./tsconfig.json",
+        JSON.stringify({ compilerOptions: {} }),
+        "utf-8"
+      );
+
+      await runWrangler("init");
+      const tsconfigJson = JSON.parse(
+        fs.readFileSync("./tsconfig.json", "utf-8")
+      );
+      expect(tsconfigJson.compilerOptions).toEqual({});
+    });
+
+    it("should not touch an existing package.json in an ancestor directory", async () => {
+      fs.writeFileSync(
+        "./package.json",
+        JSON.stringify({ name: "test", version: "1.0.0" }),
+        "utf-8"
+      );
+      fs.writeFileSync(
+        "./tsconfig.json",
+        JSON.stringify({ compilerOptions: {} }),
+        "utf-8"
       );
-      await w(`kv:namespace delete --namespace-id ${namespaceIdToDelete}`);
-      expect(KVNamespaces.find((ns) => ns.id === namespaceIdToDelete)).toBe(
-        undefined
+
+      fs.mkdirSync("./sub-1/sub-2", { recursive: true });
+      process.chdir("./sub-1/sub-2");
+
+      await runWrangler("init");
+      expect(fs.existsSync("./tsconfig.json")).toBe(false);
+      expect(fs.existsSync("../../tsconfig.json")).toBe(true);
+
+      const tsconfigJson = JSON.parse(
+        fs.readFileSync("../../tsconfig.json", "utf-8")
+      );
+      expect(tsconfigJson.compilerOptions).toEqual({});
+    });
+
+    it("should error if `--type` is used", async () => {
+      const { error } = await runWrangler("init --type");
+      expect(error).toMatchInlineSnapshot(
+        `[Error: The --type option is no longer supported.]`
       );
     });
+
+    it("should error if `--type javascript` is used", async () => {
+      const { error } = await runWrangler("init --type javascript");
+      expect(error).toMatchInlineSnapshot(
+        `[Error: The --type option is no longer supported.]`
+      );
+    });
+
+    it("should error if `--type rust` is used", async () => {
+      const { error } = await runWrangler("init --type rust");
+      expect(error).toMatchInlineSnapshot(
+        `[Error: The --type option is no longer supported.]`
+      );
+    });
+
+    it("should error if `--type webpack` is used", async () => {
+      const { error } = await runWrangler("init --type webpack");
+      expect(error).toMatchInlineSnapshot(`
+        [Error: The --type option is no longer supported.
+        If you wish to use webpack then you will need to create a custom build.]
+      `);
+    });
   });
 });

package/src/__tests__/jest.setup.ts

@@ -0,0 +1,22 @@
+import { mockFetchInternal } from "./mock-cfetch";
+import { confirm, prompt } from "../dialogs";
+import { fetchInternal } from "../cfetch/internal";
+
+jest.mock("../cfetch/internal");
+(fetchInternal as jest.Mock).mockImplementation(mockFetchInternal);
+
+jest.mock("../dialogs");
+
+// By default (if not configured by mockConfirm()) calls to `confirm()` should throw.
+(confirm as jest.Mock).mockImplementation(() => {
+  throw new Error(
+    "Unexpected call to `confirm()`. You should use `mockConfirm()` to mock calls to `confirm()` with expectations. Search the codebase for `mockConfirm` to learn more."
+  );
+});
+
+// By default (if not configured by mockPrompt()) calls to `prompt()` should throw.
+(prompt as jest.Mock).mockImplementation(() => {
+  throw new Error(
+    "Unexpected call to `prompt()`. You should use `mockPrompt()` to mock calls to `prompt()` with expectations. Search the codebase for `mockPrompt` to learn more."
+  );
+});