wrangler 0.0.0-e9ab55a → 0.0.0-e9fae558

package/pages/functions/template-worker.ts

@@ -1,136 +0,0 @@
-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 FetchEnv = {
-  [name: string]: { fetch: typeof fetch };
-  ASSETS: { fetch: typeof fetch };
-};
-
-type WorkerContext = {
-  waitUntil: (promise: Promise<unknown>) => void;
-};
-
-function* executeRequest(request: Request, _env: FetchEnv) {
-  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;
-    }
-  }
-}
-
-export default {
-  async fetch(request: Request, env: FetchEnv, 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 result = handlerIterator.next();
-      // Note we can't use `!result.done` because this doesn't narrow to the correct type
-      if (result.done == false) {
-        const { handler, params } = result.value;
-        const context = {
-          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
-        );
-      } else if (__FALLBACK_SERVICE__) {
-        // There are no more handlers so finish with the fallback service (`env.ASSETS.fetch` in Pages' case)
-        return env[__FALLBACK_SERVICE__].fetch(request);
-      } else {
-        // There was not fallback service so actually make the request to the origin.
-        return fetch(request);
-      }
-    };
-
-    try {
-      return next();
-    } catch (err) {
-      return new Response("Internal Error", { status: 500 });
-    }
-  },
-};

package/src/__tests__/clipboardy-mock.js

@@ -1,4 +0,0 @@
-// We use this mock during tests because we're having trouble
-// properly compiling clipboardy for jest
-// We can revisit this if and when we write tests that test
-// the copying part of `dev`

package/src/__tests__/dev.test.tsx

@@ -1,67 +0,0 @@
-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()?.split("\n").slice(0, 2).join("\n"))
-      .toMatchInlineSnapshot(`
-      "Something went wrong:
-      Error: 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,287 +0,0 @@
-import * as fsp from "node:fs/promises";
-import * as TOML from "@iarna/toml";
-import { mockConfirm } from "./mock-dialogs";
-import { runWrangler } from "./run-wrangler";
-import { runInTempDir } from "./run-in-tmp";
-import * as fs from "node:fs";
-
-describe("wrangler", () => {
-  runInTempDir();
-
-  describe("no command", () => {
-    it("should display a list of available commands", async () => {
-      const { stdout, stderr } = await runWrangler();
-
-      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:
-          -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]"
-      `);
-
-      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
-
-        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 () => {
-      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 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");
-    });
-
-    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");
-    });
-
-    it("should not touch an existing package.json in an ancestor 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"
-      );
-
-      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");
-    });
-
-    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,
-        }
-      );
-      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(packageJson.devDependencies).toEqual({
-        "@cloudflare/workers-types": expect.any(String),
-      });
-    });
-
-    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"
-      );
-
-      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

@@ -1,22 +0,0 @@
-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."
-  );
-});